Remove unnecessary target dependencies on relocation format.
[external/binutils.git] / gold / mips.cc
1 // mips.cc -- mips target support for gold.
2
3 // Copyright (C) 2011-2015 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.
7
8 // This file is part of gold.
9
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.
14
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.
19
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.
24
25 #include "gold.h"
26
27 #include <algorithm>
28 #include <set>
29 #include <sstream>
30 #include "demangle.h"
31
32 #include "elfcpp.h"
33 #include "parameters.h"
34 #include "reloc.h"
35 #include "mips.h"
36 #include "object.h"
37 #include "symtab.h"
38 #include "layout.h"
39 #include "output.h"
40 #include "copy-relocs.h"
41 #include "target.h"
42 #include "target-reloc.h"
43 #include "target-select.h"
44 #include "tls.h"
45 #include "errors.h"
46 #include "gc.h"
47 #include "nacl.h"
48
49 namespace
50 {
51 using namespace gold;
52
53 template<int size, bool big_endian>
54 class Mips_output_data_plt;
55
56 template<int size, bool big_endian>
57 class Mips_output_data_got;
58
59 template<int size, bool big_endian>
60 class Target_mips;
61
62 template<int size, bool big_endian>
63 class Mips_output_section_reginfo;
64
65 template<int size, bool big_endian>
66 class Mips_output_data_la25_stub;
67
68 template<int size, bool big_endian>
69 class Mips_output_data_mips_stubs;
70
71 template<int size>
72 class Mips_symbol;
73
74 template<int size, bool big_endian>
75 class Mips_got_info;
76
77 template<int size, bool big_endian>
78 class Mips_relobj;
79
80 class Mips16_stub_section_base;
81
82 template<int size, bool big_endian>
83 class Mips16_stub_section;
84
85 // The ABI says that every symbol used by dynamic relocations must have
86 // a global GOT entry.  Among other things, this provides the dynamic
87 // linker with a free, directly-indexed cache.  The GOT can therefore
88 // contain symbols that are not referenced by GOT relocations themselves
89 // (in other words, it may have symbols that are not referenced by things
90 // like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
91
92 // GOT relocations are less likely to overflow if we put the associated
93 // GOT entries towards the beginning.  We therefore divide the global
94 // GOT entries into two areas: "normal" and "reloc-only".  Entries in
95 // the first area can be used for both dynamic relocations and GP-relative
96 // accesses, while those in the "reloc-only" area are for dynamic
97 // relocations only.
98
99 // These GGA_* ("Global GOT Area") values are organised so that lower
100 // values are more general than higher values.  Also, non-GGA_NONE
101 // values are ordered by the position of the area in the GOT.
102
103 enum Global_got_area
104 {
105   GGA_NORMAL = 0,
106   GGA_RELOC_ONLY = 1,
107   GGA_NONE = 2
108 };
109
110 // The types of GOT entries needed for this platform.
111 // These values are exposed to the ABI in an incremental link.
112 // Do not renumber existing values without changing the version
113 // number of the .gnu_incremental_inputs section.
114 enum Got_type
115 {
116   GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
117   GOT_TYPE_TLS_OFFSET = 1,    // GOT entry for TLS offset
118   GOT_TYPE_TLS_PAIR = 2,      // GOT entry for TLS module/offset pair
119
120   // GOT entries for multi-GOT. We support up to 1024 GOTs in multi-GOT links.
121   GOT_TYPE_STANDARD_MULTIGOT = 3,
122   GOT_TYPE_TLS_OFFSET_MULTIGOT = GOT_TYPE_STANDARD_MULTIGOT + 1024,
123   GOT_TYPE_TLS_PAIR_MULTIGOT = GOT_TYPE_TLS_OFFSET_MULTIGOT + 1024
124 };
125
126 // TLS type of GOT entry.
127 enum Got_tls_type
128 {
129   GOT_TLS_NONE = 0,
130   GOT_TLS_GD = 1,
131   GOT_TLS_LDM = 2,
132   GOT_TLS_IE = 4
133 };
134
135 // Return TRUE if a relocation of type R_TYPE from OBJECT might
136 // require an la25 stub.  See also local_pic_function, which determines
137 // whether the destination function ever requires a stub.
138 template<int size, bool big_endian>
139 static inline bool
140 relocation_needs_la25_stub(Mips_relobj<size, big_endian>* object,
141                            unsigned int r_type, bool target_is_16_bit_code)
142 {
143   // We specifically ignore branches and jumps from EF_PIC objects,
144   // where the onus is on the compiler or programmer to perform any
145   // necessary initialization of $25.  Sometimes such initialization
146   // is unnecessary; for example, -mno-shared functions do not use
147   // the incoming value of $25, and may therefore be called directly.
148   if (object->is_pic())
149     return false;
150
151   switch (r_type)
152     {
153     case elfcpp::R_MIPS_26:
154     case elfcpp::R_MIPS_PC16:
155     case elfcpp::R_MICROMIPS_26_S1:
156     case elfcpp::R_MICROMIPS_PC7_S1:
157     case elfcpp::R_MICROMIPS_PC10_S1:
158     case elfcpp::R_MICROMIPS_PC16_S1:
159     case elfcpp::R_MICROMIPS_PC23_S2:
160       return true;
161
162     case elfcpp::R_MIPS16_26:
163       return !target_is_16_bit_code;
164
165     default:
166       return false;
167     }
168 }
169
170 // Return true if SYM is a locally-defined PIC function, in the sense
171 // that it or its fn_stub might need $25 to be valid on entry.
172 // Note that MIPS16 functions set up $gp using PC-relative instructions,
173 // so they themselves never need $25 to be valid.  Only non-MIPS16
174 // entry points are of interest here.
175 template<int size, bool big_endian>
176 static inline bool
177 local_pic_function(Mips_symbol<size>* sym)
178 {
179   bool def_regular = (sym->source() == Symbol::FROM_OBJECT
180                       && !sym->object()->is_dynamic()
181                       && !sym->is_undefined());
182
183   if (sym->is_defined() && def_regular)
184     {
185       Mips_relobj<size, big_endian>* object =
186         static_cast<Mips_relobj<size, big_endian>*>(sym->object());
187
188       if ((object->is_pic() || sym->is_pic())
189           && (!sym->is_mips16()
190               || (sym->has_mips16_fn_stub() && sym->need_fn_stub())))
191         return true;
192     }
193   return false;
194 }
195
196 static inline bool
197 hi16_reloc(int r_type)
198 {
199   return (r_type == elfcpp::R_MIPS_HI16
200           || r_type == elfcpp::R_MIPS16_HI16
201           || r_type == elfcpp::R_MICROMIPS_HI16);
202 }
203
204 static inline bool
205 lo16_reloc(int r_type)
206 {
207   return (r_type == elfcpp::R_MIPS_LO16
208           || r_type == elfcpp::R_MIPS16_LO16
209           || r_type == elfcpp::R_MICROMIPS_LO16);
210 }
211
212 static inline bool
213 got16_reloc(unsigned int r_type)
214 {
215   return (r_type == elfcpp::R_MIPS_GOT16
216           || r_type == elfcpp::R_MIPS16_GOT16
217           || r_type == elfcpp::R_MICROMIPS_GOT16);
218 }
219
220 static inline bool
221 call_lo16_reloc(unsigned int r_type)
222 {
223   return (r_type == elfcpp::R_MIPS_CALL_LO16
224           || r_type == elfcpp::R_MICROMIPS_CALL_LO16);
225 }
226
227 static inline bool
228 got_lo16_reloc(unsigned int r_type)
229 {
230   return (r_type == elfcpp::R_MIPS_GOT_LO16
231           || r_type == elfcpp::R_MICROMIPS_GOT_LO16);
232 }
233
234 static inline bool
235 got_disp_reloc(unsigned int r_type)
236 {
237   return (r_type == elfcpp::R_MIPS_GOT_DISP
238           || r_type == elfcpp::R_MICROMIPS_GOT_DISP);
239 }
240
241 static inline bool
242 got_page_reloc(unsigned int r_type)
243 {
244   return (r_type == elfcpp::R_MIPS_GOT_PAGE
245           || r_type == elfcpp::R_MICROMIPS_GOT_PAGE);
246 }
247
248 static inline bool
249 tls_gd_reloc(unsigned int r_type)
250 {
251   return (r_type == elfcpp::R_MIPS_TLS_GD
252           || r_type == elfcpp::R_MIPS16_TLS_GD
253           || r_type == elfcpp::R_MICROMIPS_TLS_GD);
254 }
255
256 static inline bool
257 tls_gottprel_reloc(unsigned int r_type)
258 {
259   return (r_type == elfcpp::R_MIPS_TLS_GOTTPREL
260           || r_type == elfcpp::R_MIPS16_TLS_GOTTPREL
261           || r_type == elfcpp::R_MICROMIPS_TLS_GOTTPREL);
262 }
263
264 static inline bool
265 tls_ldm_reloc(unsigned int r_type)
266 {
267   return (r_type == elfcpp::R_MIPS_TLS_LDM
268           || r_type == elfcpp::R_MIPS16_TLS_LDM
269           || r_type == elfcpp::R_MICROMIPS_TLS_LDM);
270 }
271
272 static inline bool
273 mips16_call_reloc(unsigned int r_type)
274 {
275   return (r_type == elfcpp::R_MIPS16_26
276           || r_type == elfcpp::R_MIPS16_CALL16);
277 }
278
279 static inline bool
280 jal_reloc(unsigned int r_type)
281 {
282   return (r_type == elfcpp::R_MIPS_26
283           || r_type == elfcpp::R_MIPS16_26
284           || r_type == elfcpp::R_MICROMIPS_26_S1);
285 }
286
287 static inline bool
288 micromips_branch_reloc(unsigned int r_type)
289 {
290   return (r_type == elfcpp::R_MICROMIPS_26_S1
291           || r_type == elfcpp::R_MICROMIPS_PC16_S1
292           || r_type == elfcpp::R_MICROMIPS_PC10_S1
293           || r_type == elfcpp::R_MICROMIPS_PC7_S1);
294 }
295
296 // Check if R_TYPE is a MIPS16 reloc.
297 static inline bool
298 mips16_reloc(unsigned int r_type)
299 {
300   switch (r_type)
301     {
302     case elfcpp::R_MIPS16_26:
303     case elfcpp::R_MIPS16_GPREL:
304     case elfcpp::R_MIPS16_GOT16:
305     case elfcpp::R_MIPS16_CALL16:
306     case elfcpp::R_MIPS16_HI16:
307     case elfcpp::R_MIPS16_LO16:
308     case elfcpp::R_MIPS16_TLS_GD:
309     case elfcpp::R_MIPS16_TLS_LDM:
310     case elfcpp::R_MIPS16_TLS_DTPREL_HI16:
311     case elfcpp::R_MIPS16_TLS_DTPREL_LO16:
312     case elfcpp::R_MIPS16_TLS_GOTTPREL:
313     case elfcpp::R_MIPS16_TLS_TPREL_HI16:
314     case elfcpp::R_MIPS16_TLS_TPREL_LO16:
315       return true;
316
317     default:
318       return false;
319     }
320 }
321
322 // Check if R_TYPE is a microMIPS reloc.
323 static inline bool
324 micromips_reloc(unsigned int r_type)
325 {
326   switch (r_type)
327     {
328     case elfcpp::R_MICROMIPS_26_S1:
329     case elfcpp::R_MICROMIPS_HI16:
330     case elfcpp::R_MICROMIPS_LO16:
331     case elfcpp::R_MICROMIPS_GPREL16:
332     case elfcpp::R_MICROMIPS_LITERAL:
333     case elfcpp::R_MICROMIPS_GOT16:
334     case elfcpp::R_MICROMIPS_PC7_S1:
335     case elfcpp::R_MICROMIPS_PC10_S1:
336     case elfcpp::R_MICROMIPS_PC16_S1:
337     case elfcpp::R_MICROMIPS_CALL16:
338     case elfcpp::R_MICROMIPS_GOT_DISP:
339     case elfcpp::R_MICROMIPS_GOT_PAGE:
340     case elfcpp::R_MICROMIPS_GOT_OFST:
341     case elfcpp::R_MICROMIPS_GOT_HI16:
342     case elfcpp::R_MICROMIPS_GOT_LO16:
343     case elfcpp::R_MICROMIPS_SUB:
344     case elfcpp::R_MICROMIPS_HIGHER:
345     case elfcpp::R_MICROMIPS_HIGHEST:
346     case elfcpp::R_MICROMIPS_CALL_HI16:
347     case elfcpp::R_MICROMIPS_CALL_LO16:
348     case elfcpp::R_MICROMIPS_SCN_DISP:
349     case elfcpp::R_MICROMIPS_JALR:
350     case elfcpp::R_MICROMIPS_HI0_LO16:
351     case elfcpp::R_MICROMIPS_TLS_GD:
352     case elfcpp::R_MICROMIPS_TLS_LDM:
353     case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16:
354     case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16:
355     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
356     case elfcpp::R_MICROMIPS_TLS_TPREL_HI16:
357     case elfcpp::R_MICROMIPS_TLS_TPREL_LO16:
358     case elfcpp::R_MICROMIPS_GPREL7_S2:
359     case elfcpp::R_MICROMIPS_PC23_S2:
360       return true;
361
362     default:
363       return false;
364     }
365 }
366
367 static inline bool
368 is_matching_lo16_reloc(unsigned int high_reloc, unsigned int lo16_reloc)
369 {
370   switch (high_reloc)
371     {
372     case elfcpp::R_MIPS_HI16:
373     case elfcpp::R_MIPS_GOT16:
374       return lo16_reloc == elfcpp::R_MIPS_LO16;
375     case elfcpp::R_MIPS16_HI16:
376     case elfcpp::R_MIPS16_GOT16:
377       return lo16_reloc == elfcpp::R_MIPS16_LO16;
378     case elfcpp::R_MICROMIPS_HI16:
379     case elfcpp::R_MICROMIPS_GOT16:
380       return lo16_reloc == elfcpp::R_MICROMIPS_LO16;
381     default:
382       return false;
383     }
384 }
385
386 // This class is used to hold information about one GOT entry.
387 // There are three types of entry:
388 //
389 //    (1) a SYMBOL + OFFSET address, where SYMBOL is local to an input object
390 //          (object != NULL, symndx >= 0, tls_type != GOT_TLS_LDM)
391 //    (2) a SYMBOL address, where SYMBOL is not local to an input object
392 //          (object != NULL, symndx == -1)
393 //    (3) a TLS LDM slot
394 //          (object != NULL, symndx == 0, tls_type == GOT_TLS_LDM)
395
396 template<int size, bool big_endian>
397 class Mips_got_entry
398 {
399   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
400
401  public:
402   Mips_got_entry(Mips_relobj<size, big_endian>* object, unsigned int symndx,
403                  Mips_address addend, unsigned char tls_type,
404                  unsigned int shndx)
405     : object_(object), symndx_(symndx), tls_type_(tls_type), shndx_(shndx)
406   { this->d.addend = addend; }
407
408   Mips_got_entry(Mips_relobj<size, big_endian>* object, Mips_symbol<size>* sym,
409                  unsigned char tls_type)
410     : object_(object), symndx_(-1U), tls_type_(tls_type), shndx_(-1U)
411   { this->d.sym = sym; }
412
413   // Return whether this entry is for a local symbol.
414   bool
415   is_for_local_symbol() const
416   { return this->symndx_ != -1U; }
417
418   // Return whether this entry is for a global symbol.
419   bool
420   is_for_global_symbol() const
421   { return this->symndx_ == -1U; }
422
423   // Return the hash of this entry.
424   size_t
425   hash() const
426   {
427     if (this->tls_type_ == GOT_TLS_LDM)
428       return this->symndx_ + (1 << 18);
429     if (this->symndx_ != -1U)
430       {
431         uintptr_t object_id = reinterpret_cast<uintptr_t>(this->object());
432         return this->symndx_ + object_id + this->d.addend;
433       }
434     else
435       {
436         uintptr_t sym_id = reinterpret_cast<uintptr_t>(this->d.sym);
437         return this->symndx_ + sym_id;
438       }
439   }
440
441   // Return whether this entry is equal to OTHER.
442   bool
443   equals(Mips_got_entry<size, big_endian>* other) const
444   {
445     if (this->symndx_ != other->symndx_
446         || this->tls_type_ != other->tls_type_)
447       return false;
448     if (this->tls_type_ == GOT_TLS_LDM)
449       return true;
450     if (this->symndx_ != -1U)
451       return (this->object() == other->object()
452               && this->d.addend == other->d.addend);
453     else
454       return this->d.sym == other->d.sym;
455   }
456
457   // Return input object that needs this GOT entry.
458   Mips_relobj<size, big_endian>*
459   object() const
460   {
461     gold_assert(this->object_ != NULL);
462     return this->object_;
463   }
464
465   // Return local symbol index for local GOT entries.
466   unsigned int
467   symndx() const
468   {
469     gold_assert(this->symndx_ != -1U);
470     return this->symndx_;
471   }
472
473   // Return the relocation addend for local GOT entries.
474   Mips_address
475   addend() const
476   {
477     gold_assert(this->symndx_ != -1U);
478     return this->d.addend;
479   }
480
481   // Return global symbol for global GOT entries.
482   Mips_symbol<size>*
483   sym() const
484   {
485     gold_assert(this->symndx_ == -1U);
486     return this->d.sym;
487   }
488
489   // Return whether this is a TLS GOT entry.
490   bool
491   is_tls_entry() const
492   { return this->tls_type_ != GOT_TLS_NONE; }
493
494   // Return TLS type of this GOT entry.
495   unsigned char
496   tls_type() const
497   { return this->tls_type_; }
498
499   // Return section index of the local symbol for local GOT entries.
500   unsigned int
501   shndx() const
502   { return this->shndx_; }
503
504  private:
505   // The input object that needs the GOT entry.
506   Mips_relobj<size, big_endian>* object_;
507   // The index of the symbol if we have a local symbol; -1 otherwise.
508   unsigned int symndx_;
509
510   union
511   {
512     // If symndx != -1, the addend of the relocation that should be added to the
513     // symbol value.
514     Mips_address addend;
515     // If symndx == -1, the global symbol corresponding to this GOT entry.  The
516     // symbol's entry is in the local area if mips_sym->global_got_area is
517     // GGA_NONE, otherwise it is in the global area.
518     Mips_symbol<size>* sym;
519   } d;
520
521   // The TLS type of this GOT entry.  An LDM GOT entry will be a local
522   // symbol entry with r_symndx == 0.
523   unsigned char tls_type_;
524
525   // For local GOT entries, section index of the local symbol.
526   unsigned int shndx_;
527 };
528
529 // Hash for Mips_got_entry.
530
531 template<int size, bool big_endian>
532 class Mips_got_entry_hash
533 {
534  public:
535   size_t
536   operator()(Mips_got_entry<size, big_endian>* entry) const
537   { return entry->hash(); }
538 };
539
540 // Equality for Mips_got_entry.
541
542 template<int size, bool big_endian>
543 class Mips_got_entry_eq
544 {
545  public:
546   bool
547   operator()(Mips_got_entry<size, big_endian>* e1,
548              Mips_got_entry<size, big_endian>* e2) const
549   { return e1->equals(e2); }
550 };
551
552 // Got_page_range.  This class describes a range of addends: [MIN_ADDEND,
553 // MAX_ADDEND].  The instances form a non-overlapping list that is sorted by
554 // increasing MIN_ADDEND.
555
556 struct Got_page_range
557 {
558   Got_page_range()
559     : next(NULL), min_addend(0), max_addend(0)
560   { }
561
562   Got_page_range* next;
563   int min_addend;
564   int max_addend;
565
566   // Return the maximum number of GOT page entries required.
567   int
568   get_max_pages()
569   { return (this->max_addend - this->min_addend + 0x1ffff) >> 16; }
570 };
571
572 // Got_page_entry.  This class describes the range of addends that are applied
573 // to page relocations against a given symbol.
574
575 struct Got_page_entry
576 {
577   Got_page_entry()
578     : object(NULL), symndx(-1U), ranges(NULL), num_pages(0)
579   { }
580
581   Got_page_entry(Object* object_, unsigned int symndx_)
582     : object(object_), symndx(symndx_), ranges(NULL), num_pages(0)
583   { }
584
585   // The input object that needs the GOT page entry.
586   Object* object;
587   // The index of the symbol, as stored in the relocation r_info.
588   unsigned int symndx;
589   // The ranges for this page entry.
590   Got_page_range* ranges;
591   // The maximum number of page entries needed for RANGES.
592   unsigned int num_pages;
593 };
594
595 // Hash for Got_page_entry.
596
597 struct Got_page_entry_hash
598 {
599   size_t
600   operator()(Got_page_entry* entry) const
601   { return reinterpret_cast<uintptr_t>(entry->object) + entry->symndx; }
602 };
603
604 // Equality for Got_page_entry.
605
606 struct Got_page_entry_eq
607 {
608   bool
609   operator()(Got_page_entry* entry1, Got_page_entry* entry2) const
610   {
611     return entry1->object == entry2->object && entry1->symndx == entry2->symndx;
612   }
613 };
614
615 // This class is used to hold .got information when linking.
616
617 template<int size, bool big_endian>
618 class Mips_got_info
619 {
620   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
621   typedef Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>
622     Reloc_section;
623   typedef Unordered_map<unsigned int, unsigned int> Got_page_offsets;
624
625   // Unordered set of GOT entries.
626   typedef Unordered_set<Mips_got_entry<size, big_endian>*,
627       Mips_got_entry_hash<size, big_endian>,
628       Mips_got_entry_eq<size, big_endian> > Got_entry_set;
629
630   // Unordered set of GOT page entries.
631   typedef Unordered_set<Got_page_entry*,
632       Got_page_entry_hash, Got_page_entry_eq> Got_page_entry_set;
633
634  public:
635   Mips_got_info()
636     : local_gotno_(0), page_gotno_(0), global_gotno_(0), reloc_only_gotno_(0),
637       tls_gotno_(0), tls_ldm_offset_(-1U), global_got_symbols_(),
638       got_entries_(), got_page_entries_(), got_page_offset_start_(0),
639       got_page_offset_next_(0), got_page_offsets_(), next_(NULL), index_(-1U),
640       offset_(0)
641   { }
642
643   // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
644   // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
645   void
646   record_local_got_symbol(Mips_relobj<size, big_endian>* object,
647                           unsigned int symndx, Mips_address addend,
648                           unsigned int r_type, unsigned int shndx);
649
650   // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
651   // in OBJECT.  FOR_CALL is true if the caller is only interested in
652   // using the GOT entry for calls.  DYN_RELOC is true if R_TYPE is a dynamic
653   // relocation.
654   void
655   record_global_got_symbol(Mips_symbol<size>* mips_sym,
656                            Mips_relobj<size, big_endian>* object,
657                            unsigned int r_type, bool dyn_reloc, bool for_call);
658
659   // Add ENTRY to master GOT and to OBJECT's GOT.
660   void
661   record_got_entry(Mips_got_entry<size, big_endian>* entry,
662                    Mips_relobj<size, big_endian>* object);
663
664   // Record that OBJECT has a page relocation against symbol SYMNDX and
665   // that ADDEND is the addend for that relocation.
666   void
667   record_got_page_entry(Mips_relobj<size, big_endian>* object,
668                         unsigned int symndx, int addend);
669
670   // Create all entries that should be in the local part of the GOT.
671   void
672   add_local_entries(Target_mips<size, big_endian>* target, Layout* layout);
673
674   // Create GOT page entries.
675   void
676   add_page_entries(Target_mips<size, big_endian>* target, Layout* layout);
677
678   // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY.
679   void
680   add_global_entries(Target_mips<size, big_endian>* target, Layout* layout,
681                      unsigned int non_reloc_only_global_gotno);
682
683   // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
684   void
685   add_reloc_only_entries(Mips_output_data_got<size, big_endian>* got);
686
687   // Create TLS GOT entries.
688   void
689   add_tls_entries(Target_mips<size, big_endian>* target, Layout* layout);
690
691   // Decide whether the symbol needs an entry in the global part of the primary
692   // GOT, setting global_got_area accordingly.  Count the number of global
693   // symbols that are in the primary GOT only because they have dynamic
694   // relocations R_MIPS_REL32 against them (reloc_only_gotno).
695   void
696   count_got_symbols(Symbol_table* symtab);
697
698   // Return the offset of GOT page entry for VALUE.
699   unsigned int
700   get_got_page_offset(Mips_address value,
701                       Mips_output_data_got<size, big_endian>* got);
702
703   // Count the number of GOT entries required.
704   void
705   count_got_entries();
706
707   // Count the number of GOT entries required by ENTRY.  Accumulate the result.
708   void
709   count_got_entry(Mips_got_entry<size, big_endian>* entry);
710
711   // Add FROM's GOT entries.
712   void
713   add_got_entries(Mips_got_info<size, big_endian>* from);
714
715   // Add FROM's GOT page entries.
716   void
717   add_got_page_entries(Mips_got_info<size, big_endian>* from);
718
719   // Return GOT size.
720   unsigned int
721   got_size() const
722   { return ((2 + this->local_gotno_ + this->page_gotno_ + this->global_gotno_
723              + this->tls_gotno_) * size/8);
724   }
725
726   // Return the number of local GOT entries.
727   unsigned int
728   local_gotno() const
729   { return this->local_gotno_; }
730
731   // Return the maximum number of page GOT entries needed.
732   unsigned int
733   page_gotno() const
734   { return this->page_gotno_; }
735
736   // Return the number of global GOT entries.
737   unsigned int
738   global_gotno() const
739   { return this->global_gotno_; }
740
741   // Set the number of global GOT entries.
742   void
743   set_global_gotno(unsigned int global_gotno)
744   { this->global_gotno_ = global_gotno; }
745
746   // Return the number of GGA_RELOC_ONLY global GOT entries.
747   unsigned int
748   reloc_only_gotno() const
749   { return this->reloc_only_gotno_; }
750
751   // Return the number of TLS GOT entries.
752   unsigned int
753   tls_gotno() const
754   { return this->tls_gotno_; }
755
756   // Return the GOT type for this GOT.  Used for multi-GOT links only.
757   unsigned int
758   multigot_got_type(unsigned int got_type) const
759   {
760     switch (got_type)
761       {
762       case GOT_TYPE_STANDARD:
763         return GOT_TYPE_STANDARD_MULTIGOT + this->index_;
764       case GOT_TYPE_TLS_OFFSET:
765         return GOT_TYPE_TLS_OFFSET_MULTIGOT + this->index_;
766       case GOT_TYPE_TLS_PAIR:
767         return GOT_TYPE_TLS_PAIR_MULTIGOT + this->index_;
768       default:
769         gold_unreachable();
770       }
771   }
772
773   // Remove lazy-binding stubs for global symbols in this GOT.
774   void
775   remove_lazy_stubs(Target_mips<size, big_endian>* target);
776
777   // Return offset of this GOT from the start of .got section.
778   unsigned int
779   offset() const
780   { return this->offset_; }
781
782   // Set offset of this GOT from the start of .got section.
783   void
784   set_offset(unsigned int offset)
785   { this->offset_ = offset; }
786
787   // Set index of this GOT in multi-GOT links.
788   void
789   set_index(unsigned int index)
790   { this->index_ = index; }
791
792   // Return next GOT in multi-GOT links.
793   Mips_got_info<size, big_endian>*
794   next() const
795   { return this->next_; }
796
797   // Set next GOT in multi-GOT links.
798   void
799   set_next(Mips_got_info<size, big_endian>* next)
800   { this->next_ = next; }
801
802   // Return the offset of TLS LDM entry for this GOT.
803   unsigned int
804   tls_ldm_offset() const
805   { return this->tls_ldm_offset_; }
806
807   // Set the offset of TLS LDM entry for this GOT.
808   void
809   set_tls_ldm_offset(unsigned int tls_ldm_offset)
810   { this->tls_ldm_offset_ = tls_ldm_offset; }
811
812   Unordered_set<Mips_symbol<size>*>&
813   global_got_symbols()
814   { return this->global_got_symbols_; }
815
816   // Return the GOT_TLS_* type required by relocation type R_TYPE.
817   static int
818   mips_elf_reloc_tls_type(unsigned int r_type)
819   {
820     if (tls_gd_reloc(r_type))
821       return GOT_TLS_GD;
822
823     if (tls_ldm_reloc(r_type))
824       return GOT_TLS_LDM;
825
826     if (tls_gottprel_reloc(r_type))
827       return GOT_TLS_IE;
828
829     return GOT_TLS_NONE;
830   }
831
832   // Return the number of GOT slots needed for GOT TLS type TYPE.
833   static int
834   mips_tls_got_entries(unsigned int type)
835   {
836     switch (type)
837       {
838       case GOT_TLS_GD:
839       case GOT_TLS_LDM:
840         return 2;
841
842       case GOT_TLS_IE:
843         return 1;
844
845       case GOT_TLS_NONE:
846         return 0;
847
848       default:
849         gold_unreachable();
850       }
851   }
852
853  private:
854   // The number of local GOT entries.
855   unsigned int local_gotno_;
856   // The maximum number of page GOT entries needed.
857   unsigned int page_gotno_;
858   // The number of global GOT entries.
859   unsigned int global_gotno_;
860   // The number of global GOT entries that are in the GGA_RELOC_ONLY area.
861   unsigned int reloc_only_gotno_;
862   // The number of TLS GOT entries.
863   unsigned int tls_gotno_;
864   // The offset of TLS LDM entry for this GOT.
865   unsigned int tls_ldm_offset_;
866   // All symbols that have global GOT entry.
867   Unordered_set<Mips_symbol<size>*> global_got_symbols_;
868   // A hash table holding GOT entries.
869   Got_entry_set got_entries_;
870   // A hash table of GOT page entries.
871   Got_page_entry_set got_page_entries_;
872   // The offset of first GOT page entry for this GOT.
873   unsigned int got_page_offset_start_;
874   // The offset of next available GOT page entry for this GOT.
875   unsigned int got_page_offset_next_;
876   // A hash table that maps GOT page entry value to the GOT offset where
877   // the entry is located.
878   Got_page_offsets got_page_offsets_;
879   // In multi-GOT links, a pointer to the next GOT.
880   Mips_got_info<size, big_endian>* next_;
881   // Index of this GOT in multi-GOT links.
882   unsigned int index_;
883   // The offset of this GOT in multi-GOT links.
884   unsigned int offset_;
885 };
886
887 // This is a helper class used during relocation scan.  It records GOT16 addend.
888
889 template<int size, bool big_endian>
890 struct got16_addend
891 {
892   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
893
894   got16_addend(const Sized_relobj_file<size, big_endian>* _object,
895                unsigned int _shndx, unsigned int _r_type, unsigned int _r_sym,
896                Mips_address _addend)
897     : object(_object), shndx(_shndx), r_type(_r_type), r_sym(_r_sym),
898       addend(_addend)
899   { }
900
901   const Sized_relobj_file<size, big_endian>* object;
902   unsigned int shndx;
903   unsigned int r_type;
904   unsigned int r_sym;
905   Mips_address addend;
906 };
907
908 // Mips_symbol class.  Holds additional symbol information needed for Mips.
909
910 template<int size>
911 class Mips_symbol : public Sized_symbol<size>
912 {
913  public:
914   Mips_symbol()
915     : need_fn_stub_(false), has_nonpic_branches_(false), la25_stub_offset_(-1U),
916       has_static_relocs_(false), no_lazy_stub_(false), lazy_stub_offset_(0),
917       pointer_equality_needed_(false), global_got_area_(GGA_NONE),
918       global_gotoffset_(-1U), got_only_for_calls_(true), has_lazy_stub_(false),
919       needs_mips_plt_(false), needs_comp_plt_(false), mips_plt_offset_(-1U),
920       comp_plt_offset_(-1U), mips16_fn_stub_(NULL), mips16_call_stub_(NULL),
921       mips16_call_fp_stub_(NULL), applied_secondary_got_fixup_(false)
922   { }
923
924   // Return whether this is a MIPS16 symbol.
925   bool
926   is_mips16() const
927   {
928     // (st_other & STO_MIPS16) == STO_MIPS16
929     return ((this->nonvis() & (elfcpp::STO_MIPS16 >> 2))
930             == elfcpp::STO_MIPS16 >> 2);
931   }
932
933   // Return whether this is a microMIPS symbol.
934   bool
935   is_micromips() const
936   {
937     // (st_other & STO_MIPS_ISA) == STO_MICROMIPS
938     return ((this->nonvis() & (elfcpp::STO_MIPS_ISA >> 2))
939             == elfcpp::STO_MICROMIPS >> 2);
940   }
941
942   // Return whether the symbol needs MIPS16 fn_stub.
943   bool
944   need_fn_stub() const
945   { return this->need_fn_stub_; }
946
947   // Set that the symbol needs MIPS16 fn_stub.
948   void
949   set_need_fn_stub()
950   { this->need_fn_stub_ = true; }
951
952   // Return whether this symbol is referenced by branch relocations from
953   // any non-PIC input file.
954   bool
955   has_nonpic_branches() const
956   { return this->has_nonpic_branches_; }
957
958   // Set that this symbol is referenced by branch relocations from
959   // any non-PIC input file.
960   void
961   set_has_nonpic_branches()
962   { this->has_nonpic_branches_ = true; }
963
964   // Return the offset of the la25 stub for this symbol from the start of the
965   // la25 stub section.
966   unsigned int
967   la25_stub_offset() const
968   { return this->la25_stub_offset_; }
969
970   // Set the offset of the la25 stub for this symbol from the start of the
971   // la25 stub section.
972   void
973   set_la25_stub_offset(unsigned int offset)
974   { this->la25_stub_offset_ = offset; }
975
976   // Return whether the symbol has la25 stub.  This is true if this symbol is
977   // for a PIC function, and there are non-PIC branches and jumps to it.
978   bool
979   has_la25_stub() const
980   { return this->la25_stub_offset_ != -1U; }
981
982   // Return whether there is a relocation against this symbol that must be
983   // resolved by the static linker (that is, the relocation cannot possibly
984   // be made dynamic).
985   bool
986   has_static_relocs() const
987   { return this->has_static_relocs_; }
988
989   // Set that there is a relocation against this symbol that must be resolved
990   // by the static linker (that is, the relocation cannot possibly be made
991   // dynamic).
992   void
993   set_has_static_relocs()
994   { this->has_static_relocs_ = true; }
995
996   // Return whether we must not create a lazy-binding stub for this symbol.
997   bool
998   no_lazy_stub() const
999   { return this->no_lazy_stub_; }
1000
1001   // Set that we must not create a lazy-binding stub for this symbol.
1002   void
1003   set_no_lazy_stub()
1004   { this->no_lazy_stub_ = true; }
1005
1006   // Return the offset of the lazy-binding stub for this symbol from the start
1007   // of .MIPS.stubs section.
1008   unsigned int
1009   lazy_stub_offset() const
1010   { return this->lazy_stub_offset_; }
1011
1012   // Set the offset of the lazy-binding stub for this symbol from the start
1013   // of .MIPS.stubs section.
1014   void
1015   set_lazy_stub_offset(unsigned int offset)
1016   { this->lazy_stub_offset_ = offset; }
1017
1018   // Return whether there are any relocations for this symbol where
1019   // pointer equality matters.
1020   bool
1021   pointer_equality_needed() const
1022   { return this->pointer_equality_needed_; }
1023
1024   // Set that there are relocations for this symbol where pointer equality
1025   // matters.
1026   void
1027   set_pointer_equality_needed()
1028   { this->pointer_equality_needed_ = true; }
1029
1030   // Return global GOT area where this symbol in located.
1031   Global_got_area
1032   global_got_area() const
1033   { return this->global_got_area_; }
1034
1035   // Set global GOT area where this symbol in located.
1036   void
1037   set_global_got_area(Global_got_area global_got_area)
1038   { this->global_got_area_ = global_got_area; }
1039
1040   // Return the global GOT offset for this symbol.  For multi-GOT links, this
1041   // returns the offset from the start of .got section to the first GOT entry
1042   // for the symbol.  Note that in multi-GOT links the symbol can have entry
1043   // in more than one GOT.
1044   unsigned int
1045   global_gotoffset() const
1046   { return this->global_gotoffset_; }
1047
1048   // Set the global GOT offset for this symbol.  Note that in multi-GOT links
1049   // the symbol can have entry in more than one GOT.  This method will set
1050   // the offset only if it is less than current offset.
1051   void
1052   set_global_gotoffset(unsigned int offset)
1053   {
1054     if (this->global_gotoffset_ == -1U || offset < this->global_gotoffset_)
1055       this->global_gotoffset_ = offset;
1056   }
1057
1058   // Return whether all GOT relocations for this symbol are for calls.
1059   bool
1060   got_only_for_calls() const
1061   { return this->got_only_for_calls_; }
1062
1063   // Set that there is a GOT relocation for this symbol that is not for call.
1064   void
1065   set_got_not_only_for_calls()
1066   { this->got_only_for_calls_ = false; }
1067
1068   // Return whether this is a PIC symbol.
1069   bool
1070   is_pic() const
1071   {
1072     // (st_other & STO_MIPS_FLAGS) == STO_MIPS_PIC
1073     return ((this->nonvis() & (elfcpp::STO_MIPS_FLAGS >> 2))
1074             == (elfcpp::STO_MIPS_PIC >> 2));
1075   }
1076
1077   // Set the flag in st_other field that marks this symbol as PIC.
1078   void
1079   set_pic()
1080   {
1081     if (this->is_mips16())
1082       // (st_other & ~(STO_MIPS16 | STO_MIPS_FLAGS)) | STO_MIPS_PIC
1083       this->set_nonvis((this->nonvis()
1084                         & ~((elfcpp::STO_MIPS16 >> 2)
1085                             | (elfcpp::STO_MIPS_FLAGS >> 2)))
1086                        | (elfcpp::STO_MIPS_PIC >> 2));
1087     else
1088       // (other & ~STO_MIPS_FLAGS) | STO_MIPS_PIC
1089       this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS >> 2))
1090                        | (elfcpp::STO_MIPS_PIC >> 2));
1091   }
1092
1093   // Set the flag in st_other field that marks this symbol as PLT.
1094   void
1095   set_mips_plt()
1096   {
1097     if (this->is_mips16())
1098       // (st_other & (STO_MIPS16 | ~STO_MIPS_FLAGS)) | STO_MIPS_PLT
1099       this->set_nonvis((this->nonvis()
1100                         & ((elfcpp::STO_MIPS16 >> 2)
1101                            | ~(elfcpp::STO_MIPS_FLAGS >> 2)))
1102                        | (elfcpp::STO_MIPS_PLT >> 2));
1103
1104     else
1105       // (st_other & ~STO_MIPS_FLAGS) | STO_MIPS_PLT
1106       this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS >> 2))
1107                        | (elfcpp::STO_MIPS_PLT >> 2));
1108   }
1109
1110   // Downcast a base pointer to a Mips_symbol pointer.
1111   static Mips_symbol<size>*
1112   as_mips_sym(Symbol* sym)
1113   { return static_cast<Mips_symbol<size>*>(sym); }
1114
1115   // Downcast a base pointer to a Mips_symbol pointer.
1116   static const Mips_symbol<size>*
1117   as_mips_sym(const Symbol* sym)
1118   { return static_cast<const Mips_symbol<size>*>(sym); }
1119
1120   // Return whether the symbol has lazy-binding stub.
1121   bool
1122   has_lazy_stub() const
1123   { return this->has_lazy_stub_; }
1124
1125   // Set whether the symbol has lazy-binding stub.
1126   void
1127   set_has_lazy_stub(bool has_lazy_stub)
1128   { this->has_lazy_stub_ = has_lazy_stub; }
1129
1130   // Return whether the symbol needs a standard PLT entry.
1131   bool
1132   needs_mips_plt() const
1133   { return this->needs_mips_plt_; }
1134
1135   // Set whether the symbol needs a standard PLT entry.
1136   void
1137   set_needs_mips_plt(bool needs_mips_plt)
1138   { this->needs_mips_plt_ = needs_mips_plt; }
1139
1140   // Return whether the symbol needs a compressed (MIPS16 or microMIPS) PLT
1141   // entry.
1142   bool
1143   needs_comp_plt() const
1144   { return this->needs_comp_plt_; }
1145
1146   // Set whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry.
1147   void
1148   set_needs_comp_plt(bool needs_comp_plt)
1149   { this->needs_comp_plt_ = needs_comp_plt; }
1150
1151   // Return standard PLT entry offset, or -1 if none.
1152   unsigned int
1153   mips_plt_offset() const
1154   { return this->mips_plt_offset_; }
1155
1156   // Set standard PLT entry offset.
1157   void
1158   set_mips_plt_offset(unsigned int mips_plt_offset)
1159   { this->mips_plt_offset_ = mips_plt_offset; }
1160
1161   // Return whether the symbol has standard PLT entry.
1162   bool
1163   has_mips_plt_offset() const
1164   { return this->mips_plt_offset_ != -1U; }
1165
1166   // Return compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none.
1167   unsigned int
1168   comp_plt_offset() const
1169   { return this->comp_plt_offset_; }
1170
1171   // Set compressed (MIPS16 or microMIPS) PLT entry offset.
1172   void
1173   set_comp_plt_offset(unsigned int comp_plt_offset)
1174   { this->comp_plt_offset_ = comp_plt_offset; }
1175
1176   // Return whether the symbol has compressed (MIPS16 or microMIPS) PLT entry.
1177   bool
1178   has_comp_plt_offset() const
1179   { return this->comp_plt_offset_ != -1U; }
1180
1181   // Return MIPS16 fn stub for a symbol.
1182   template<bool big_endian>
1183   Mips16_stub_section<size, big_endian>*
1184   get_mips16_fn_stub() const
1185   {
1186     return static_cast<Mips16_stub_section<size, big_endian>*>(mips16_fn_stub_);
1187   }
1188
1189   // Set MIPS16 fn stub for a symbol.
1190   void
1191   set_mips16_fn_stub(Mips16_stub_section_base* stub)
1192   { this->mips16_fn_stub_ = stub; }
1193
1194   // Return whether symbol has MIPS16 fn stub.
1195   bool
1196   has_mips16_fn_stub() const
1197   { return this->mips16_fn_stub_ != NULL; }
1198
1199   // Return MIPS16 call stub for a symbol.
1200   template<bool big_endian>
1201   Mips16_stub_section<size, big_endian>*
1202   get_mips16_call_stub() const
1203   {
1204     return static_cast<Mips16_stub_section<size, big_endian>*>(
1205       mips16_call_stub_);
1206   }
1207
1208   // Set MIPS16 call stub for a symbol.
1209   void
1210   set_mips16_call_stub(Mips16_stub_section_base* stub)
1211   { this->mips16_call_stub_ = stub; }
1212
1213   // Return whether symbol has MIPS16 call stub.
1214   bool
1215   has_mips16_call_stub() const
1216   { return this->mips16_call_stub_ != NULL; }
1217
1218   // Return MIPS16 call_fp stub for a symbol.
1219   template<bool big_endian>
1220   Mips16_stub_section<size, big_endian>*
1221   get_mips16_call_fp_stub() const
1222   {
1223     return static_cast<Mips16_stub_section<size, big_endian>*>(
1224       mips16_call_fp_stub_);
1225   }
1226
1227   // Set MIPS16 call_fp stub for a symbol.
1228   void
1229   set_mips16_call_fp_stub(Mips16_stub_section_base* stub)
1230   { this->mips16_call_fp_stub_ = stub; }
1231
1232   // Return whether symbol has MIPS16 call_fp stub.
1233   bool
1234   has_mips16_call_fp_stub() const
1235   { return this->mips16_call_fp_stub_ != NULL; }
1236
1237   bool
1238   get_applied_secondary_got_fixup() const
1239   { return applied_secondary_got_fixup_; }
1240
1241   void
1242   set_applied_secondary_got_fixup()
1243   { this->applied_secondary_got_fixup_ = true; }
1244
1245  private:
1246   // Whether the symbol needs MIPS16 fn_stub.  This is true if this symbol
1247   // appears in any relocs other than a 16 bit call.
1248   bool need_fn_stub_;
1249
1250   // True if this symbol is referenced by branch relocations from
1251   // any non-PIC input file.  This is used to determine whether an
1252   // la25 stub is required.
1253   bool has_nonpic_branches_;
1254
1255   // The offset of the la25 stub for this symbol from the start of the
1256   // la25 stub section.
1257   unsigned int la25_stub_offset_;
1258
1259   // True if there is a relocation against this symbol that must be
1260   // resolved by the static linker (that is, the relocation cannot
1261   // possibly be made dynamic).
1262   bool has_static_relocs_;
1263
1264   // Whether we must not create a lazy-binding stub for this symbol.
1265   // This is true if the symbol has relocations related to taking the
1266   // function's address.
1267   bool no_lazy_stub_;
1268
1269   // The offset of the lazy-binding stub for this symbol from the start of
1270   // .MIPS.stubs section.
1271   unsigned int lazy_stub_offset_;
1272
1273   // True if there are any relocations for this symbol where pointer equality
1274   // matters.
1275   bool pointer_equality_needed_;
1276
1277   // Global GOT area where this symbol in located, or GGA_NONE if symbol is not
1278   // in the global part of the GOT.
1279   Global_got_area global_got_area_;
1280
1281   // The global GOT offset for this symbol.  For multi-GOT links, this is offset
1282   // from the start of .got section to the first GOT entry for the symbol.
1283   // Note that in multi-GOT links the symbol can have entry in more than one GOT.
1284   unsigned int global_gotoffset_;
1285
1286   // Whether all GOT relocations for this symbol are for calls.
1287   bool got_only_for_calls_;
1288   // Whether the symbol has lazy-binding stub.
1289   bool has_lazy_stub_;
1290   // Whether the symbol needs a standard PLT entry.
1291   bool needs_mips_plt_;
1292   // Whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry.
1293   bool needs_comp_plt_;
1294   // Standard PLT entry offset, or -1 if none.
1295   unsigned int mips_plt_offset_;
1296   // Compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none.
1297   unsigned int comp_plt_offset_;
1298   // MIPS16 fn stub for a symbol.
1299   Mips16_stub_section_base* mips16_fn_stub_;
1300   // MIPS16 call stub for a symbol.
1301   Mips16_stub_section_base* mips16_call_stub_;
1302   // MIPS16 call_fp stub for a symbol.
1303   Mips16_stub_section_base* mips16_call_fp_stub_;
1304
1305   bool applied_secondary_got_fixup_;
1306 };
1307
1308 // Mips16_stub_section class.
1309
1310 // The mips16 compiler uses a couple of special sections to handle
1311 // floating point arguments.
1312
1313 // Section names that look like .mips16.fn.FNNAME contain stubs that
1314 // copy floating point arguments from the fp regs to the gp regs and
1315 // then jump to FNNAME.  If any 32 bit function calls FNNAME, the
1316 // call should be redirected to the stub instead.  If no 32 bit
1317 // function calls FNNAME, the stub should be discarded.  We need to
1318 // consider any reference to the function, not just a call, because
1319 // if the address of the function is taken we will need the stub,
1320 // since the address might be passed to a 32 bit function.
1321
1322 // Section names that look like .mips16.call.FNNAME contain stubs
1323 // that copy floating point arguments from the gp regs to the fp
1324 // regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
1325 // then any 16 bit function that calls FNNAME should be redirected
1326 // to the stub instead.  If FNNAME is not a 32 bit function, the
1327 // stub should be discarded.
1328
1329 // .mips16.call.fp.FNNAME sections are similar, but contain stubs
1330 // which call FNNAME and then copy the return value from the fp regs
1331 // to the gp regs.  These stubs store the return address in $18 while
1332 // calling FNNAME; any function which might call one of these stubs
1333 // must arrange to save $18 around the call.  (This case is not
1334 // needed for 32 bit functions that call 16 bit functions, because
1335 // 16 bit functions always return floating point values in both
1336 // $f0/$f1 and $2/$3.)
1337
1338 // Note that in all cases FNNAME might be defined statically.
1339 // Therefore, FNNAME is not used literally.  Instead, the relocation
1340 // information will indicate which symbol the section is for.
1341
1342 // We record any stubs that we find in the symbol table.
1343
1344 // TODO(sasa): All mips16 stub sections should be emitted in the .text section.
1345
1346 class Mips16_stub_section_base { };
1347
1348 template<int size, bool big_endian>
1349 class Mips16_stub_section : public Mips16_stub_section_base
1350 {
1351   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
1352
1353  public:
1354   Mips16_stub_section(Mips_relobj<size, big_endian>* object, unsigned int shndx)
1355     : object_(object), shndx_(shndx), r_sym_(0), gsym_(NULL),
1356       found_r_mips_none_(false)
1357   {
1358     gold_assert(object->is_mips16_fn_stub_section(shndx)
1359                 || object->is_mips16_call_stub_section(shndx)
1360                 || object->is_mips16_call_fp_stub_section(shndx));
1361   }
1362
1363   // Return the object of this stub section.
1364   Mips_relobj<size, big_endian>*
1365   object() const
1366   { return this->object_; }
1367
1368   // Return the size of a section.
1369   uint64_t
1370   section_size() const
1371   { return this->object_->section_size(this->shndx_); }
1372
1373   // Return section index of this stub section.
1374   unsigned int
1375   shndx() const
1376   { return this->shndx_; }
1377
1378   // Return symbol index, if stub is for a local function.
1379   unsigned int
1380   r_sym() const
1381   { return this->r_sym_; }
1382
1383   // Return symbol, if stub is for a global function.
1384   Mips_symbol<size>*
1385   gsym() const
1386   { return this->gsym_; }
1387
1388   // Return whether stub is for a local function.
1389   bool
1390   is_for_local_function() const
1391   { return this->gsym_ == NULL; }
1392
1393   // This method is called when a new relocation R_TYPE for local symbol R_SYM
1394   // is found in the stub section.  Try to find stub target.
1395   void
1396   new_local_reloc_found(unsigned int r_type, unsigned int r_sym)
1397   {
1398     // To find target symbol for this stub, trust the first R_MIPS_NONE
1399     // relocation, if any.  Otherwise trust the first relocation, whatever
1400     // its kind.
1401     if (this->found_r_mips_none_)
1402       return;
1403     if (r_type == elfcpp::R_MIPS_NONE)
1404       {
1405         this->r_sym_ = r_sym;
1406         this->gsym_ = NULL;
1407         this->found_r_mips_none_ = true;
1408       }
1409     else if (!is_target_found())
1410       this->r_sym_ = r_sym;
1411   }
1412
1413   // This method is called when a new relocation R_TYPE for global symbol GSYM
1414   // is found in the stub section.  Try to find stub target.
1415   void
1416   new_global_reloc_found(unsigned int r_type, Mips_symbol<size>* gsym)
1417   {
1418     // To find target symbol for this stub, trust the first R_MIPS_NONE
1419     // relocation, if any.  Otherwise trust the first relocation, whatever
1420     // its kind.
1421     if (this->found_r_mips_none_)
1422       return;
1423     if (r_type == elfcpp::R_MIPS_NONE)
1424       {
1425         this->gsym_ = gsym;
1426         this->r_sym_ = 0;
1427         this->found_r_mips_none_ = true;
1428       }
1429     else if (!is_target_found())
1430       this->gsym_ = gsym;
1431   }
1432
1433   // Return whether we found the stub target.
1434   bool
1435   is_target_found() const
1436   { return this->r_sym_ != 0 || this->gsym_ != NULL;  }
1437
1438   // Return whether this is a fn stub.
1439   bool
1440   is_fn_stub() const
1441   { return this->object_->is_mips16_fn_stub_section(this->shndx_); }
1442
1443   // Return whether this is a call stub.
1444   bool
1445   is_call_stub() const
1446   { return this->object_->is_mips16_call_stub_section(this->shndx_); }
1447
1448   // Return whether this is a call_fp stub.
1449   bool
1450   is_call_fp_stub() const
1451   { return this->object_->is_mips16_call_fp_stub_section(this->shndx_); }
1452
1453   // Return the output address.
1454   Mips_address
1455   output_address() const
1456   {
1457     return (this->object_->output_section(this->shndx_)->address()
1458             + this->object_->output_section_offset(this->shndx_));
1459   }
1460
1461  private:
1462   // The object of this stub section.
1463   Mips_relobj<size, big_endian>* object_;
1464   // The section index of this stub section.
1465   unsigned int shndx_;
1466   // The symbol index, if stub is for a local function.
1467   unsigned int r_sym_;
1468   // The symbol, if stub is for a global function.
1469   Mips_symbol<size>* gsym_;
1470   // True if we found R_MIPS_NONE relocation in this stub.
1471   bool found_r_mips_none_;
1472 };
1473
1474 // Mips_relobj class.
1475
1476 template<int size, bool big_endian>
1477 class Mips_relobj : public Sized_relobj_file<size, big_endian>
1478 {
1479   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
1480   typedef std::map<unsigned int, Mips16_stub_section<size, big_endian>*>
1481     Mips16_stubs_int_map;
1482   typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype;
1483
1484  public:
1485   Mips_relobj(const std::string& name, Input_file* input_file, off_t offset,
1486               const typename elfcpp::Ehdr<size, big_endian>& ehdr)
1487     : Sized_relobj_file<size, big_endian>(name, input_file, offset, ehdr),
1488       processor_specific_flags_(0), local_symbol_is_mips16_(),
1489       local_symbol_is_micromips_(), mips16_stub_sections_(),
1490       local_non_16bit_calls_(), local_16bit_calls_(), local_mips16_fn_stubs_(),
1491       local_mips16_call_stubs_(), gp_(0), got_info_(NULL),
1492       section_is_mips16_fn_stub_(), section_is_mips16_call_stub_(),
1493       section_is_mips16_call_fp_stub_(), pdr_shndx_(-1U), gprmask_(0),
1494       cprmask1_(0), cprmask2_(0), cprmask3_(0), cprmask4_(0)
1495   {
1496     this->is_pic_ = (ehdr.get_e_flags() & elfcpp::EF_MIPS_PIC) != 0;
1497     this->is_n32_ = elfcpp::abi_n32(ehdr.get_e_flags());
1498     this->is_n64_ = elfcpp::abi_64(ehdr.get_e_ident()[elfcpp::EI_CLASS]);
1499   }
1500
1501   ~Mips_relobj()
1502   { }
1503
1504   // Downcast a base pointer to a Mips_relobj pointer.  This is
1505   // not type-safe but we only use Mips_relobj not the base class.
1506   static Mips_relobj<size, big_endian>*
1507   as_mips_relobj(Relobj* relobj)
1508   { return static_cast<Mips_relobj<size, big_endian>*>(relobj); }
1509
1510   // Downcast a base pointer to a Mips_relobj pointer.  This is
1511   // not type-safe but we only use Mips_relobj not the base class.
1512   static const Mips_relobj<size, big_endian>*
1513   as_mips_relobj(const Relobj* relobj)
1514   { return static_cast<const Mips_relobj<size, big_endian>*>(relobj); }
1515
1516   // Processor-specific flags in ELF file header.  This is valid only after
1517   // reading symbols.
1518   elfcpp::Elf_Word
1519   processor_specific_flags() const
1520   { return this->processor_specific_flags_; }
1521
1522   // Whether a local symbol is MIPS16 symbol.  R_SYM is the symbol table
1523   // index.  This is only valid after do_count_local_symbol is called.
1524   bool
1525   local_symbol_is_mips16(unsigned int r_sym) const
1526   {
1527     gold_assert(r_sym < this->local_symbol_is_mips16_.size());
1528     return this->local_symbol_is_mips16_[r_sym];
1529   }
1530
1531   // Whether a local symbol is microMIPS symbol.  R_SYM is the symbol table
1532   // index.  This is only valid after do_count_local_symbol is called.
1533   bool
1534   local_symbol_is_micromips(unsigned int r_sym) const
1535   {
1536     gold_assert(r_sym < this->local_symbol_is_micromips_.size());
1537     return this->local_symbol_is_micromips_[r_sym];
1538   }
1539
1540   // Get or create MIPS16 stub section.
1541   Mips16_stub_section<size, big_endian>*
1542   get_mips16_stub_section(unsigned int shndx)
1543   {
1544     typename Mips16_stubs_int_map::const_iterator it =
1545       this->mips16_stub_sections_.find(shndx);
1546     if (it != this->mips16_stub_sections_.end())
1547       return (*it).second;
1548
1549     Mips16_stub_section<size, big_endian>* stub_section =
1550       new Mips16_stub_section<size, big_endian>(this, shndx);
1551     this->mips16_stub_sections_.insert(
1552       std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>(
1553         stub_section->shndx(), stub_section));
1554     return stub_section;
1555   }
1556
1557   // Return MIPS16 fn stub section for local symbol R_SYM, or NULL if this
1558   // object doesn't have fn stub for R_SYM.
1559   Mips16_stub_section<size, big_endian>*
1560   get_local_mips16_fn_stub(unsigned int r_sym) const
1561   {
1562     typename Mips16_stubs_int_map::const_iterator it =
1563       this->local_mips16_fn_stubs_.find(r_sym);
1564     if (it != this->local_mips16_fn_stubs_.end())
1565       return (*it).second;
1566     return NULL;
1567   }
1568
1569   // Record that this object has MIPS16 fn stub for local symbol.  This method
1570   // is only called if we decided not to discard the stub.
1571   void
1572   add_local_mips16_fn_stub(Mips16_stub_section<size, big_endian>* stub)
1573   {
1574     gold_assert(stub->is_for_local_function());
1575     unsigned int r_sym = stub->r_sym();
1576     this->local_mips16_fn_stubs_.insert(
1577       std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>(
1578         r_sym, stub));
1579   }
1580
1581   // Return MIPS16 call stub section for local symbol R_SYM, or NULL if this
1582   // object doesn't have call stub for R_SYM.
1583   Mips16_stub_section<size, big_endian>*
1584   get_local_mips16_call_stub(unsigned int r_sym) const
1585   {
1586     typename Mips16_stubs_int_map::const_iterator it =
1587       this->local_mips16_call_stubs_.find(r_sym);
1588     if (it != this->local_mips16_call_stubs_.end())
1589       return (*it).second;
1590     return NULL;
1591   }
1592
1593   // Record that this object has MIPS16 call stub for local symbol.  This method
1594   // is only called if we decided not to discard the stub.
1595   void
1596   add_local_mips16_call_stub(Mips16_stub_section<size, big_endian>* stub)
1597   {
1598     gold_assert(stub->is_for_local_function());
1599     unsigned int r_sym = stub->r_sym();
1600     this->local_mips16_call_stubs_.insert(
1601       std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>(
1602         r_sym, stub));
1603   }
1604
1605   // Record that we found "non 16-bit" call relocation against local symbol
1606   // SYMNDX.  This reloc would need to refer to a MIPS16 fn stub, if there
1607   // is one.
1608   void
1609   add_local_non_16bit_call(unsigned int symndx)
1610   { this->local_non_16bit_calls_.insert(symndx); }
1611
1612   // Return true if there is any "non 16-bit" call relocation against local
1613   // symbol SYMNDX in this object.
1614   bool
1615   has_local_non_16bit_call_relocs(unsigned int symndx)
1616   {
1617     return (this->local_non_16bit_calls_.find(symndx)
1618             != this->local_non_16bit_calls_.end());
1619   }
1620
1621   // Record that we found 16-bit call relocation R_MIPS16_26 against local
1622   // symbol SYMNDX.  Local MIPS16 call or call_fp stubs will only be needed
1623   // if there is some R_MIPS16_26 relocation that refers to the stub symbol.
1624   void
1625   add_local_16bit_call(unsigned int symndx)
1626   { this->local_16bit_calls_.insert(symndx); }
1627
1628   // Return true if there is any 16-bit call relocation R_MIPS16_26 against local
1629   // symbol SYMNDX in this object.
1630   bool
1631   has_local_16bit_call_relocs(unsigned int symndx)
1632   {
1633     return (this->local_16bit_calls_.find(symndx)
1634             != this->local_16bit_calls_.end());
1635   }
1636
1637   // Get gp value that was used to create this object.
1638   Mips_address
1639   gp_value() const
1640   { return this->gp_; }
1641
1642   // Return whether the object is a PIC object.
1643   bool
1644   is_pic() const
1645   { return this->is_pic_; }
1646
1647   // Return whether the object uses N32 ABI.
1648   bool
1649   is_n32() const
1650   { return this->is_n32_; }
1651
1652   // Return whether the object uses N64 ABI.
1653   bool
1654   is_n64() const
1655   { return this->is_n64_; }
1656
1657   // Return whether the object uses NewABI conventions.
1658   bool
1659   is_newabi() const
1660   { return this->is_n32_ || this->is_n64_; }
1661
1662   // Return Mips_got_info for this object.
1663   Mips_got_info<size, big_endian>*
1664   get_got_info() const
1665   { return this->got_info_; }
1666
1667   // Return Mips_got_info for this object.  Create new info if it doesn't exist.
1668   Mips_got_info<size, big_endian>*
1669   get_or_create_got_info()
1670   {
1671     if (!this->got_info_)
1672       this->got_info_ = new Mips_got_info<size, big_endian>();
1673     return this->got_info_;
1674   }
1675
1676   // Set Mips_got_info for this object.
1677   void
1678   set_got_info(Mips_got_info<size, big_endian>* got_info)
1679   { this->got_info_ = got_info; }
1680
1681   // Whether a section SHDNX is a MIPS16 stub section.  This is only valid
1682   // after do_read_symbols is called.
1683   bool
1684   is_mips16_stub_section(unsigned int shndx)
1685   {
1686     return (is_mips16_fn_stub_section(shndx)
1687             || is_mips16_call_stub_section(shndx)
1688             || is_mips16_call_fp_stub_section(shndx));
1689   }
1690
1691   // Return TRUE if relocations in section SHNDX can refer directly to a
1692   // MIPS16 function rather than to a hard-float stub.  This is only valid
1693   // after do_read_symbols is called.
1694   bool
1695   section_allows_mips16_refs(unsigned int shndx)
1696   {
1697     return (this->is_mips16_stub_section(shndx) || shndx == this->pdr_shndx_);
1698   }
1699
1700   // Whether a section SHDNX is a MIPS16 fn stub section.  This is only valid
1701   // after do_read_symbols is called.
1702   bool
1703   is_mips16_fn_stub_section(unsigned int shndx)
1704   {
1705     gold_assert(shndx < this->section_is_mips16_fn_stub_.size());
1706     return this->section_is_mips16_fn_stub_[shndx];
1707   }
1708
1709   // Whether a section SHDNX is a MIPS16 call stub section.  This is only valid
1710   // after do_read_symbols is called.
1711   bool
1712   is_mips16_call_stub_section(unsigned int shndx)
1713   {
1714     gold_assert(shndx < this->section_is_mips16_call_stub_.size());
1715     return this->section_is_mips16_call_stub_[shndx];
1716   }
1717
1718   // Whether a section SHDNX is a MIPS16 call_fp stub section.  This is only
1719   // valid after do_read_symbols is called.
1720   bool
1721   is_mips16_call_fp_stub_section(unsigned int shndx)
1722   {
1723     gold_assert(shndx < this->section_is_mips16_call_fp_stub_.size());
1724     return this->section_is_mips16_call_fp_stub_[shndx];
1725   }
1726
1727   // Discard MIPS16 stub secions that are not needed.
1728   void
1729   discard_mips16_stub_sections(Symbol_table* symtab);
1730
1731   // Return gprmask from the .reginfo section of this object.
1732   Valtype
1733   gprmask() const
1734   { return this->gprmask_; }
1735
1736   // Return cprmask1 from the .reginfo section of this object.
1737   Valtype
1738   cprmask1() const
1739   { return this->cprmask1_; }
1740
1741   // Return cprmask2 from the .reginfo section of this object.
1742   Valtype
1743   cprmask2() const
1744   { return this->cprmask2_; }
1745
1746   // Return cprmask3 from the .reginfo section of this object.
1747   Valtype
1748   cprmask3() const
1749   { return this->cprmask3_; }
1750
1751   // Return cprmask4 from the .reginfo section of this object.
1752   Valtype
1753   cprmask4() const
1754   { return this->cprmask4_; }
1755
1756  protected:
1757   // Count the local symbols.
1758   void
1759   do_count_local_symbols(Stringpool_template<char>*,
1760                          Stringpool_template<char>*);
1761
1762   // Read the symbol information.
1763   void
1764   do_read_symbols(Read_symbols_data* sd);
1765
1766  private:
1767   // processor-specific flags in ELF file header.
1768   elfcpp::Elf_Word processor_specific_flags_;
1769
1770   // Bit vector to tell if a local symbol is a MIPS16 symbol or not.
1771   // This is only valid after do_count_local_symbol is called.
1772   std::vector<bool> local_symbol_is_mips16_;
1773
1774   // Bit vector to tell if a local symbol is a microMIPS symbol or not.
1775   // This is only valid after do_count_local_symbol is called.
1776   std::vector<bool> local_symbol_is_micromips_;
1777
1778   // Map from section index to the MIPS16 stub for that section.  This contains
1779   // all stubs found in this object.
1780   Mips16_stubs_int_map mips16_stub_sections_;
1781
1782   // Local symbols that have "non 16-bit" call relocation.  This relocation
1783   // would need to refer to a MIPS16 fn stub, if there is one.
1784   std::set<unsigned int> local_non_16bit_calls_;
1785
1786   // Local symbols that have 16-bit call relocation R_MIPS16_26.  Local MIPS16
1787   // call or call_fp stubs will only be needed if there is some R_MIPS16_26
1788   // relocation that refers to the stub symbol.
1789   std::set<unsigned int> local_16bit_calls_;
1790
1791   // Map from local symbol index to the MIPS16 fn stub for that symbol.
1792   // This contains only the stubs that we decided not to discard.
1793   Mips16_stubs_int_map local_mips16_fn_stubs_;
1794
1795   // Map from local symbol index to the MIPS16 call stub for that symbol.
1796   // This contains only the stubs that we decided not to discard.
1797   Mips16_stubs_int_map local_mips16_call_stubs_;
1798
1799   // gp value that was used to create this object.
1800   Mips_address gp_;
1801   // Whether the object is a PIC object.
1802   bool is_pic_ : 1;
1803   // Whether the object uses N32 ABI.
1804   bool is_n32_ : 1;
1805   // Whether the object uses N64 ABI.
1806   bool is_n64_ : 1;
1807   // The Mips_got_info for this object.
1808   Mips_got_info<size, big_endian>* got_info_;
1809
1810   // Bit vector to tell if a section is a MIPS16 fn stub section or not.
1811   // This is only valid after do_read_symbols is called.
1812   std::vector<bool> section_is_mips16_fn_stub_;
1813
1814   // Bit vector to tell if a section is a MIPS16 call stub section or not.
1815   // This is only valid after do_read_symbols is called.
1816   std::vector<bool> section_is_mips16_call_stub_;
1817
1818   // Bit vector to tell if a section is a MIPS16 call_fp stub section or not.
1819   // This is only valid after do_read_symbols is called.
1820   std::vector<bool> section_is_mips16_call_fp_stub_;
1821
1822   // .pdr section index.
1823   unsigned int pdr_shndx_;
1824
1825   // gprmask from the .reginfo section of this object.
1826   Valtype gprmask_;
1827   // cprmask1 from the .reginfo section of this object.
1828   Valtype cprmask1_;
1829   // cprmask2 from the .reginfo section of this object.
1830   Valtype cprmask2_;
1831   // cprmask3 from the .reginfo section of this object.
1832   Valtype cprmask3_;
1833   // cprmask4 from the .reginfo section of this object.
1834   Valtype cprmask4_;
1835 };
1836
1837 // Mips_output_data_got class.
1838
1839 template<int size, bool big_endian>
1840 class Mips_output_data_got : public Output_data_got<size, big_endian>
1841 {
1842   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
1843   typedef Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>
1844     Reloc_section;
1845   typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype;
1846
1847  public:
1848   Mips_output_data_got(Target_mips<size, big_endian>* target,
1849       Symbol_table* symtab, Layout* layout)
1850     : Output_data_got<size, big_endian>(), target_(target),
1851       symbol_table_(symtab), layout_(layout), static_relocs_(), got_view_(NULL),
1852       first_global_got_dynsym_index_(-1U), primary_got_(NULL),
1853       secondary_got_relocs_()
1854   {
1855     this->master_got_info_ = new Mips_got_info<size, big_endian>();
1856     this->set_addralign(16);
1857   }
1858
1859   // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
1860   // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
1861   void
1862   record_local_got_symbol(Mips_relobj<size, big_endian>* object,
1863                           unsigned int symndx, Mips_address addend,
1864                           unsigned int r_type, unsigned int shndx)
1865   {
1866     this->master_got_info_->record_local_got_symbol(object, symndx, addend,
1867                                                     r_type, shndx);
1868   }
1869
1870   // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
1871   // in OBJECT.  FOR_CALL is true if the caller is only interested in
1872   // using the GOT entry for calls.  DYN_RELOC is true if R_TYPE is a dynamic
1873   // relocation.
1874   void
1875   record_global_got_symbol(Mips_symbol<size>* mips_sym,
1876                            Mips_relobj<size, big_endian>* object,
1877                            unsigned int r_type, bool dyn_reloc, bool for_call)
1878   {
1879     this->master_got_info_->record_global_got_symbol(mips_sym, object, r_type,
1880                                                      dyn_reloc, for_call);
1881   }
1882
1883   // Record that OBJECT has a page relocation against symbol SYMNDX and
1884   // that ADDEND is the addend for that relocation.
1885   void
1886   record_got_page_entry(Mips_relobj<size, big_endian>* object,
1887                         unsigned int symndx, int addend)
1888   { this->master_got_info_->record_got_page_entry(object, symndx, addend); }
1889
1890   // Add a static entry for the GOT entry at OFFSET.  GSYM is a global
1891   // symbol and R_TYPE is the code of a dynamic relocation that needs to be
1892   // applied in a static link.
1893   void
1894   add_static_reloc(unsigned int got_offset, unsigned int r_type,
1895                    Mips_symbol<size>* gsym)
1896   { this->static_relocs_.push_back(Static_reloc(got_offset, r_type, gsym)); }
1897
1898   // Add a static reloc for the GOT entry at OFFSET.  RELOBJ is an object
1899   // defining a local symbol with INDEX.  R_TYPE is the code of a dynamic
1900   // relocation that needs to be applied in a static link.
1901   void
1902   add_static_reloc(unsigned int got_offset, unsigned int r_type,
1903                    Sized_relobj_file<size, big_endian>* relobj,
1904                    unsigned int index)
1905   {
1906     this->static_relocs_.push_back(Static_reloc(got_offset, r_type, relobj,
1907                                                 index));
1908   }
1909
1910   // Record that global symbol GSYM has R_TYPE dynamic relocation in the
1911   // secondary GOT at OFFSET.
1912   void
1913   add_secondary_got_reloc(unsigned int got_offset, unsigned int r_type,
1914                           Mips_symbol<size>* gsym)
1915   {
1916     this->secondary_got_relocs_.push_back(Static_reloc(got_offset,
1917                                                        r_type, gsym));
1918   }
1919
1920   // Update GOT entry at OFFSET with VALUE.
1921   void
1922   update_got_entry(unsigned int offset, Mips_address value)
1923   {
1924     elfcpp::Swap<size, big_endian>::writeval(this->got_view_ + offset, value);
1925   }
1926
1927   // Return the number of entries in local part of the GOT.  This includes
1928   // local entries, page entries and 2 reserved entries.
1929   unsigned int
1930   get_local_gotno() const
1931   {
1932     if (!this->multi_got())
1933       {
1934         return (2 + this->master_got_info_->local_gotno()
1935                 + this->master_got_info_->page_gotno());
1936       }
1937     else
1938       return 2 + this->primary_got_->local_gotno() + this->primary_got_->page_gotno();
1939   }
1940
1941   // Return dynamic symbol table index of the first symbol with global GOT
1942   // entry.
1943   unsigned int
1944   first_global_got_dynsym_index() const
1945   { return this->first_global_got_dynsym_index_; }
1946
1947   // Set dynamic symbol table index of the first symbol with global GOT entry.
1948   void
1949   set_first_global_got_dynsym_index(unsigned int index)
1950   { this->first_global_got_dynsym_index_ = index; }
1951
1952   // Lay out the GOT.  Add local, global and TLS entries.  If GOT is
1953   // larger than 64K, create multi-GOT.
1954   void
1955   lay_out_got(Layout* layout, Symbol_table* symtab,
1956               const Input_objects* input_objects);
1957
1958   // Create multi-GOT.  For every GOT, add local, global and TLS entries.
1959   void
1960   lay_out_multi_got(Layout* layout, const Input_objects* input_objects);
1961
1962   // Attempt to merge GOTs of different input objects.
1963   void
1964   merge_gots(const Input_objects* input_objects);
1965
1966   // Consider merging FROM, which is OBJECT's GOT, into TO.  Return false if
1967   // this would lead to overflow, true if they were merged successfully.
1968   bool
1969   merge_got_with(Mips_got_info<size, big_endian>* from,
1970                  Mips_relobj<size, big_endian>* object,
1971                  Mips_got_info<size, big_endian>* to);
1972
1973   // Return the offset of GOT page entry for VALUE.  For multi-GOT links,
1974   // use OBJECT's GOT.
1975   unsigned int
1976   get_got_page_offset(Mips_address value,
1977                       const Mips_relobj<size, big_endian>* object)
1978   {
1979     Mips_got_info<size, big_endian>* g = (!this->multi_got()
1980                                           ? this->master_got_info_
1981                                           : object->get_got_info());
1982     gold_assert(g != NULL);
1983     return g->get_got_page_offset(value, this);
1984   }
1985
1986   // Return the GOT offset of type GOT_TYPE of the global symbol
1987   // GSYM.  For multi-GOT links, use OBJECT's GOT.
1988   unsigned int got_offset(const Symbol* gsym, unsigned int got_type,
1989                           Mips_relobj<size, big_endian>* object) const
1990   {
1991     if (!this->multi_got())
1992       return gsym->got_offset(got_type);
1993     else
1994       {
1995         Mips_got_info<size, big_endian>* g = object->get_got_info();
1996         gold_assert(g != NULL);
1997         return gsym->got_offset(g->multigot_got_type(got_type));
1998       }
1999   }
2000
2001   // Return the GOT offset of type GOT_TYPE of the local symbol
2002   // SYMNDX.
2003   unsigned int
2004   got_offset(unsigned int symndx, unsigned int got_type,
2005              Sized_relobj_file<size, big_endian>* object) const
2006   { return object->local_got_offset(symndx, got_type); }
2007
2008   // Return the offset of TLS LDM entry.  For multi-GOT links, use OBJECT's GOT.
2009   unsigned int
2010   tls_ldm_offset(Mips_relobj<size, big_endian>* object) const
2011   {
2012     Mips_got_info<size, big_endian>* g = (!this->multi_got()
2013                                           ? this->master_got_info_
2014                                           : object->get_got_info());
2015     gold_assert(g != NULL);
2016     return g->tls_ldm_offset();
2017   }
2018
2019   // Set the offset of TLS LDM entry.  For multi-GOT links, use OBJECT's GOT.
2020   void
2021   set_tls_ldm_offset(unsigned int tls_ldm_offset,
2022                      Mips_relobj<size, big_endian>* object)
2023   {
2024     Mips_got_info<size, big_endian>* g = (!this->multi_got()
2025                                           ? this->master_got_info_
2026                                           : object->get_got_info());
2027     gold_assert(g != NULL);
2028     g->set_tls_ldm_offset(tls_ldm_offset);
2029   }
2030
2031   // Return true for multi-GOT links.
2032   bool
2033   multi_got() const
2034   { return this->primary_got_ != NULL; }
2035
2036   // Return the offset of OBJECT's GOT from the start of .got section.
2037   unsigned int
2038   get_got_offset(const Mips_relobj<size, big_endian>* object)
2039   {
2040     if (!this->multi_got())
2041       return 0;
2042     else
2043       {
2044         Mips_got_info<size, big_endian>* g = object->get_got_info();
2045         return g != NULL ? g->offset() : 0;
2046       }
2047   }
2048
2049   // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
2050   void
2051   add_reloc_only_entries()
2052   { this->master_got_info_->add_reloc_only_entries(this); }
2053
2054   // Return offset of the primary GOT's entry for global symbol.
2055   unsigned int
2056   get_primary_got_offset(const Mips_symbol<size>* sym) const
2057   {
2058     gold_assert(sym->global_got_area() != GGA_NONE);
2059     return (this->get_local_gotno() + sym->dynsym_index()
2060             - this->first_global_got_dynsym_index()) * size/8;
2061   }
2062
2063   // For the entry at offset GOT_OFFSET, return its offset from the gp.
2064   // Input argument GOT_OFFSET is always global offset from the start of
2065   // .got section, for both single and multi-GOT links.
2066   // For single GOT links, this returns GOT_OFFSET - 0x7FF0.  For multi-GOT
2067   // links, the return value is object_got_offset - 0x7FF0, where
2068   // object_got_offset is offset in the OBJECT's GOT.
2069   int
2070   gp_offset(unsigned int got_offset,
2071             const Mips_relobj<size, big_endian>* object) const
2072   {
2073     return (this->address() + got_offset
2074             - this->target_->adjusted_gp_value(object));
2075   }
2076
2077  protected:
2078   // Write out the GOT table.
2079   void
2080   do_write(Output_file*);
2081
2082  private:
2083
2084   // This class represent dynamic relocations that need to be applied by
2085   // gold because we are using TLS relocations in a static link.
2086   class Static_reloc
2087   {
2088    public:
2089     Static_reloc(unsigned int got_offset, unsigned int r_type,
2090                  Mips_symbol<size>* gsym)
2091       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(true)
2092     { this->u_.global.symbol = gsym; }
2093
2094     Static_reloc(unsigned int got_offset, unsigned int r_type,
2095           Sized_relobj_file<size, big_endian>* relobj, unsigned int index)
2096       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(false)
2097     {
2098       this->u_.local.relobj = relobj;
2099       this->u_.local.index = index;
2100     }
2101
2102     // Return the GOT offset.
2103     unsigned int
2104     got_offset() const
2105     { return this->got_offset_; }
2106
2107     // Relocation type.
2108     unsigned int
2109     r_type() const
2110     { return this->r_type_; }
2111
2112     // Whether the symbol is global or not.
2113     bool
2114     symbol_is_global() const
2115     { return this->symbol_is_global_; }
2116
2117     // For a relocation against a global symbol, the global symbol.
2118     Mips_symbol<size>*
2119     symbol() const
2120     {
2121       gold_assert(this->symbol_is_global_);
2122       return this->u_.global.symbol;
2123     }
2124
2125     // For a relocation against a local symbol, the defining object.
2126     Sized_relobj_file<size, big_endian>*
2127     relobj() const
2128     {
2129       gold_assert(!this->symbol_is_global_);
2130       return this->u_.local.relobj;
2131     }
2132
2133     // For a relocation against a local symbol, the local symbol index.
2134     unsigned int
2135     index() const
2136     {
2137       gold_assert(!this->symbol_is_global_);
2138       return this->u_.local.index;
2139     }
2140
2141    private:
2142     // GOT offset of the entry to which this relocation is applied.
2143     unsigned int got_offset_;
2144     // Type of relocation.
2145     unsigned int r_type_;
2146     // Whether this relocation is against a global symbol.
2147     bool symbol_is_global_;
2148     // A global or local symbol.
2149     union
2150     {
2151       struct
2152       {
2153         // For a global symbol, the symbol itself.
2154         Mips_symbol<size>* symbol;
2155       } global;
2156       struct
2157       {
2158         // For a local symbol, the object defining object.
2159         Sized_relobj_file<size, big_endian>* relobj;
2160         // For a local symbol, the symbol index.
2161         unsigned int index;
2162       } local;
2163     } u_;
2164   };
2165
2166   // The target.
2167   Target_mips<size, big_endian>* target_;
2168   // The symbol table.
2169   Symbol_table* symbol_table_;
2170   // The layout.
2171   Layout* layout_;
2172   // Static relocs to be applied to the GOT.
2173   std::vector<Static_reloc> static_relocs_;
2174   // .got section view.
2175   unsigned char* got_view_;
2176   // The dynamic symbol table index of the first symbol with global GOT entry.
2177   unsigned int first_global_got_dynsym_index_;
2178   // The master GOT information.
2179   Mips_got_info<size, big_endian>* master_got_info_;
2180   // The  primary GOT information.
2181   Mips_got_info<size, big_endian>* primary_got_;
2182   // Secondary GOT fixups.
2183   std::vector<Static_reloc> secondary_got_relocs_;
2184 };
2185
2186 // A class to handle LA25 stubs - non-PIC interface to a PIC function. There are
2187 // two ways of creating these interfaces.  The first is to add:
2188 //
2189 //      lui     $25,%hi(func)
2190 //      j       func
2191 //      addiu   $25,$25,%lo(func)
2192 //
2193 // to a separate trampoline section.  The second is to add:
2194 //
2195 //      lui     $25,%hi(func)
2196 //      addiu   $25,$25,%lo(func)
2197 //
2198 // immediately before a PIC function "func", but only if a function is at the
2199 // beginning of the section, and the section is not too heavily aligned (i.e we
2200 // would need to add no more than 2 nops before the stub.)
2201 //
2202 // We only create stubs of the first type.
2203
2204 template<int size, bool big_endian>
2205 class Mips_output_data_la25_stub : public Output_section_data
2206 {
2207   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
2208
2209  public:
2210   Mips_output_data_la25_stub()
2211   : Output_section_data(size == 32 ? 4 : 8), symbols_()
2212   { }
2213
2214   // Create LA25 stub for a symbol.
2215   void
2216   create_la25_stub(Symbol_table* symtab, Target_mips<size, big_endian>* target,
2217                    Mips_symbol<size>* gsym);
2218
2219   // Return output address of a stub.
2220   Mips_address
2221   stub_address(const Mips_symbol<size>* sym) const
2222   {
2223     gold_assert(sym->has_la25_stub());
2224     return this->address() + sym->la25_stub_offset();
2225   }
2226
2227  protected:
2228   void
2229   do_adjust_output_section(Output_section* os)
2230   { os->set_entsize(0); }
2231
2232  private:
2233   // Template for standard LA25 stub.
2234   static const uint32_t la25_stub_entry[];
2235   // Template for microMIPS LA25 stub.
2236   static const uint32_t la25_stub_micromips_entry[];
2237
2238   // Set the final size.
2239   void
2240   set_final_data_size()
2241   { this->set_data_size(this->symbols_.size() * 16); }
2242
2243   // Create a symbol for SYM stub's value and size, to help make the
2244   // disassembly easier to read.
2245   void
2246   create_stub_symbol(Mips_symbol<size>* sym, Symbol_table* symtab,
2247                      Target_mips<size, big_endian>* target, uint64_t symsize);
2248
2249   // Write out the LA25 stub section.
2250   void
2251   do_write(Output_file*);
2252
2253   // Symbols that have LA25 stubs.
2254   Unordered_set<Mips_symbol<size>*> symbols_;
2255 };
2256
2257 // A class to handle the PLT data.
2258
2259 template<int size, bool big_endian>
2260 class Mips_output_data_plt : public Output_section_data
2261 {
2262   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
2263   typedef Output_data_reloc<elfcpp::SHT_REL, true,
2264                             size, big_endian> Reloc_section;
2265
2266  public:
2267   // Create the PLT section.  The ordinary .got section is an argument,
2268   // since we need to refer to the start.
2269   Mips_output_data_plt(Layout* layout, Output_data_space* got_plt,
2270                        Target_mips<size, big_endian>* target)
2271     : Output_section_data(size == 32 ? 4 : 8), got_plt_(got_plt), symbols_(),
2272       plt_mips_offset_(0), plt_comp_offset_(0), plt_header_size_(0),
2273       target_(target)
2274   {
2275     this->rel_ = new Reloc_section(false);
2276     layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
2277                                     elfcpp::SHF_ALLOC, this->rel_,
2278                                     ORDER_DYNAMIC_PLT_RELOCS, false);
2279   }
2280
2281   // Add an entry to the PLT for a symbol referenced by r_type relocation.
2282   void
2283   add_entry(Mips_symbol<size>* gsym, unsigned int r_type);
2284
2285   // Return the .rel.plt section data.
2286   const Reloc_section*
2287   rel_plt() const
2288   { return this->rel_; }
2289
2290   // Return the number of PLT entries.
2291   unsigned int
2292   entry_count() const
2293   { return this->symbols_.size(); }
2294
2295   // Return the offset of the first non-reserved PLT entry.
2296   unsigned int
2297   first_plt_entry_offset() const
2298   { return sizeof(plt0_entry_o32); }
2299
2300   // Return the size of a PLT entry.
2301   unsigned int
2302   plt_entry_size() const
2303   { return sizeof(plt_entry); }
2304
2305   // Set final PLT offsets.  For each symbol, determine whether standard or
2306   // compressed (MIPS16 or microMIPS) PLT entry is used.
2307   void
2308   set_plt_offsets();
2309
2310   // Return the offset of the first standard PLT entry.
2311   unsigned int
2312   first_mips_plt_offset() const
2313   { return this->plt_header_size_; }
2314
2315   // Return the offset of the first compressed PLT entry.
2316   unsigned int
2317   first_comp_plt_offset() const
2318   { return this->plt_header_size_ + this->plt_mips_offset_; }
2319
2320   // Return whether there are any standard PLT entries.
2321   bool
2322   has_standard_entries() const
2323   { return this->plt_mips_offset_ > 0; }
2324
2325   // Return the output address of standard PLT entry.
2326   Mips_address
2327   mips_entry_address(const Mips_symbol<size>* sym) const
2328   {
2329     gold_assert (sym->has_mips_plt_offset());
2330     return (this->address() + this->first_mips_plt_offset()
2331             + sym->mips_plt_offset());
2332   }
2333
2334   // Return the output address of compressed (MIPS16 or microMIPS) PLT entry.
2335   Mips_address
2336   comp_entry_address(const Mips_symbol<size>* sym) const
2337   {
2338     gold_assert (sym->has_comp_plt_offset());
2339     return (this->address() + this->first_comp_plt_offset()
2340             + sym->comp_plt_offset());
2341   }
2342
2343  protected:
2344   void
2345   do_adjust_output_section(Output_section* os)
2346   { os->set_entsize(0); }
2347
2348   // Write to a map file.
2349   void
2350   do_print_to_mapfile(Mapfile* mapfile) const
2351   { mapfile->print_output_data(this, _(".plt")); }
2352
2353  private:
2354   // Template for the first PLT entry.
2355   static const uint32_t plt0_entry_o32[];
2356   static const uint32_t plt0_entry_n32[];
2357   static const uint32_t plt0_entry_n64[];
2358   static const uint32_t plt0_entry_micromips_o32[];
2359   static const uint32_t plt0_entry_micromips32_o32[];
2360
2361   // Template for subsequent PLT entries.
2362   static const uint32_t plt_entry[];
2363   static const uint32_t plt_entry_mips16_o32[];
2364   static const uint32_t plt_entry_micromips_o32[];
2365   static const uint32_t plt_entry_micromips32_o32[];
2366
2367   // Set the final size.
2368   void
2369   set_final_data_size()
2370   {
2371     this->set_data_size(this->plt_header_size_ + this->plt_mips_offset_
2372                         + this->plt_comp_offset_);
2373   }
2374
2375   // Write out the PLT data.
2376   void
2377   do_write(Output_file*);
2378
2379   // Return whether the plt header contains microMIPS code.  For the sake of
2380   // cache alignment always use a standard header whenever any standard entries
2381   // are present even if microMIPS entries are present as well.  This also lets
2382   // the microMIPS header rely on the value of $v0 only set by microMIPS
2383   // entries, for a small size reduction.
2384   bool
2385   is_plt_header_compressed() const
2386   {
2387     gold_assert(this->plt_mips_offset_ + this->plt_comp_offset_ != 0);
2388     return this->target_->is_output_micromips() && this->plt_mips_offset_ == 0;
2389   }
2390
2391   // Return the size of the PLT header.
2392   unsigned int
2393   get_plt_header_size() const
2394   {
2395     if (this->target_->is_output_n64())
2396       return 4 * sizeof(plt0_entry_n64) / sizeof(plt0_entry_n64[0]);
2397     else if (this->target_->is_output_n32())
2398       return 4 * sizeof(plt0_entry_n32) / sizeof(plt0_entry_n32[0]);
2399     else if (!this->is_plt_header_compressed())
2400       return 4 * sizeof(plt0_entry_o32) / sizeof(plt0_entry_o32[0]);
2401     else if (this->target_->use_32bit_micromips_instructions())
2402       return (2 * sizeof(plt0_entry_micromips32_o32)
2403               / sizeof(plt0_entry_micromips32_o32[0]));
2404     else
2405       return (2 * sizeof(plt0_entry_micromips_o32)
2406               / sizeof(plt0_entry_micromips_o32[0]));
2407   }
2408
2409   // Return the PLT header entry.
2410   const uint32_t*
2411   get_plt_header_entry() const
2412   {
2413     if (this->target_->is_output_n64())
2414       return plt0_entry_n64;
2415     else if (this->target_->is_output_n32())
2416       return plt0_entry_n32;
2417     else if (!this->is_plt_header_compressed())
2418       return plt0_entry_o32;
2419     else if (this->target_->use_32bit_micromips_instructions())
2420       return plt0_entry_micromips32_o32;
2421     else
2422       return plt0_entry_micromips_o32;
2423   }
2424
2425   // Return the size of the standard PLT entry.
2426   unsigned int
2427   standard_plt_entry_size() const
2428   { return 4 * sizeof(plt_entry) / sizeof(plt_entry[0]); }
2429
2430   // Return the size of the compressed PLT entry.
2431   unsigned int
2432   compressed_plt_entry_size() const
2433   {
2434     gold_assert(!this->target_->is_output_newabi());
2435
2436     if (!this->target_->is_output_micromips())
2437       return (2 * sizeof(plt_entry_mips16_o32)
2438               / sizeof(plt_entry_mips16_o32[0]));
2439     else if (this->target_->use_32bit_micromips_instructions())
2440       return (2 * sizeof(plt_entry_micromips32_o32)
2441               / sizeof(plt_entry_micromips32_o32[0]));
2442     else
2443       return (2 * sizeof(plt_entry_micromips_o32)
2444               / sizeof(plt_entry_micromips_o32[0]));
2445   }
2446
2447   // The reloc section.
2448   Reloc_section* rel_;
2449   // The .got.plt section.
2450   Output_data_space* got_plt_;
2451   // Symbols that have PLT entry.
2452   std::vector<Mips_symbol<size>*> symbols_;
2453   // The offset of the next standard PLT entry to create.
2454   unsigned int plt_mips_offset_;
2455   // The offset of the next compressed PLT entry to create.
2456   unsigned int plt_comp_offset_;
2457   // The size of the PLT header in bytes.
2458   unsigned int plt_header_size_;
2459   // The target.
2460   Target_mips<size, big_endian>* target_;
2461 };
2462
2463 // A class to handle the .MIPS.stubs data.
2464
2465 template<int size, bool big_endian>
2466 class Mips_output_data_mips_stubs : public Output_section_data
2467 {
2468   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
2469
2470  public:
2471    Mips_output_data_mips_stubs(Target_mips<size, big_endian>* target)
2472      : Output_section_data(size == 32 ? 4 : 8), symbols_(), dynsym_count_(-1U),
2473        stub_offsets_are_set_(false), target_(target)
2474    { }
2475
2476   // Create entry for a symbol.
2477   void
2478   make_entry(Mips_symbol<size>*);
2479
2480   // Remove entry for a symbol.
2481   void
2482   remove_entry(Mips_symbol<size>* gsym);
2483
2484   // Set stub offsets for symbols.  This method expects that the number of
2485   // entries in dynamic symbol table is set.
2486   void
2487   set_lazy_stub_offsets();
2488
2489   void
2490   set_needs_dynsym_value();
2491
2492    // Set the number of entries in dynamic symbol table.
2493   void
2494   set_dynsym_count(unsigned int dynsym_count)
2495   { this->dynsym_count_ = dynsym_count; }
2496
2497   // Return maximum size of the stub, ie. the stub size if the dynamic symbol
2498   // count is greater than 0x10000.  If the dynamic symbol count is less than
2499   // 0x10000, the stub will be 4 bytes smaller.
2500   // There's no disadvantage from using microMIPS code here, so for the sake of
2501   // pure-microMIPS binaries we prefer it whenever there's any microMIPS code in
2502   // output produced at all.  This has a benefit of stubs being shorter by
2503   // 4 bytes each too, unless in the insn32 mode.
2504   unsigned int
2505   stub_max_size() const
2506   {
2507     if (!this->target_->is_output_micromips()
2508         || this->target_->use_32bit_micromips_instructions())
2509       return 20;
2510     else
2511       return 16;
2512   }
2513
2514   // Return the size of the stub.  This method expects that the final dynsym
2515   // count is set.
2516   unsigned int
2517   stub_size() const
2518   {
2519     gold_assert(this->dynsym_count_ != -1U);
2520     if (this->dynsym_count_ > 0x10000)
2521       return this->stub_max_size();
2522     else
2523       return this->stub_max_size() - 4;
2524   }
2525
2526   // Return output address of a stub.
2527   Mips_address
2528   stub_address(const Mips_symbol<size>* sym) const
2529   {
2530     gold_assert(sym->has_lazy_stub());
2531     return this->address() + sym->lazy_stub_offset();
2532   }
2533
2534  protected:
2535   void
2536   do_adjust_output_section(Output_section* os)
2537   { os->set_entsize(0); }
2538
2539   // Write to a map file.
2540   void
2541   do_print_to_mapfile(Mapfile* mapfile) const
2542   { mapfile->print_output_data(this, _(".MIPS.stubs")); }
2543
2544  private:
2545   static const uint32_t lazy_stub_normal_1[];
2546   static const uint32_t lazy_stub_normal_1_n64[];
2547   static const uint32_t lazy_stub_normal_2[];
2548   static const uint32_t lazy_stub_normal_2_n64[];
2549   static const uint32_t lazy_stub_big[];
2550   static const uint32_t lazy_stub_big_n64[];
2551
2552   static const uint32_t lazy_stub_micromips_normal_1[];
2553   static const uint32_t lazy_stub_micromips_normal_1_n64[];
2554   static const uint32_t lazy_stub_micromips_normal_2[];
2555   static const uint32_t lazy_stub_micromips_normal_2_n64[];
2556   static const uint32_t lazy_stub_micromips_big[];
2557   static const uint32_t lazy_stub_micromips_big_n64[];
2558
2559   static const uint32_t lazy_stub_micromips32_normal_1[];
2560   static const uint32_t lazy_stub_micromips32_normal_1_n64[];
2561   static const uint32_t lazy_stub_micromips32_normal_2[];
2562   static const uint32_t lazy_stub_micromips32_normal_2_n64[];
2563   static const uint32_t lazy_stub_micromips32_big[];
2564   static const uint32_t lazy_stub_micromips32_big_n64[];
2565
2566   // Set the final size.
2567   void
2568   set_final_data_size()
2569   { this->set_data_size(this->symbols_.size() * this->stub_max_size()); }
2570
2571   // Write out the .MIPS.stubs data.
2572   void
2573   do_write(Output_file*);
2574
2575   // .MIPS.stubs symbols
2576   Unordered_set<Mips_symbol<size>*> symbols_;
2577   // Number of entries in dynamic symbol table.
2578   unsigned int dynsym_count_;
2579   // Whether the stub offsets are set.
2580   bool stub_offsets_are_set_;
2581   // The target.
2582   Target_mips<size, big_endian>* target_;
2583 };
2584
2585 // This class handles Mips .reginfo output section.
2586
2587 template<int size, bool big_endian>
2588 class Mips_output_section_reginfo : public Output_section
2589 {
2590   typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype;
2591
2592  public:
2593   Mips_output_section_reginfo(const char* name, elfcpp::Elf_Word type,
2594                               elfcpp::Elf_Xword flags,
2595                               Target_mips<size, big_endian>* target)
2596     : Output_section(name, type, flags), target_(target), gprmask_(0),
2597       cprmask1_(0), cprmask2_(0), cprmask3_(0), cprmask4_(0)
2598   { }
2599
2600   // Downcast a base pointer to a Mips_output_section_reginfo pointer.
2601   static Mips_output_section_reginfo<size, big_endian>*
2602   as_mips_output_section_reginfo(Output_section* os)
2603   { return static_cast<Mips_output_section_reginfo<size, big_endian>*>(os); }
2604
2605   // Set masks of the output .reginfo section.
2606   void
2607   set_masks(Valtype gprmask, Valtype cprmask1, Valtype cprmask2,
2608             Valtype cprmask3, Valtype cprmask4)
2609   {
2610     this->gprmask_ = gprmask;
2611     this->cprmask1_ = cprmask1;
2612     this->cprmask2_ = cprmask2;
2613     this->cprmask3_ = cprmask3;
2614     this->cprmask4_ = cprmask4;
2615   }
2616
2617  protected:
2618   // Set the final data size.
2619   void
2620   set_final_data_size()
2621   { this->set_data_size(24); }
2622
2623   // Write out reginfo section.
2624   void
2625   do_write(Output_file* of);
2626
2627  private:
2628   Target_mips<size, big_endian>* target_;
2629
2630   // gprmask of the output .reginfo section.
2631   Valtype gprmask_;
2632   // cprmask1 of the output .reginfo section.
2633   Valtype cprmask1_;
2634   // cprmask2 of the output .reginfo section.
2635   Valtype cprmask2_;
2636   // cprmask3 of the output .reginfo section.
2637   Valtype cprmask3_;
2638   // cprmask4 of the output .reginfo section.
2639   Valtype cprmask4_;
2640 };
2641
2642 // The MIPS target has relocation types which default handling of relocatable
2643 // relocation cannot process.  So we have to extend the default code.
2644
2645 template<bool big_endian, int sh_type, typename Classify_reloc>
2646 class Mips_scan_relocatable_relocs :
2647   public Default_scan_relocatable_relocs<sh_type, Classify_reloc>
2648 {
2649  public:
2650   // Return the strategy to use for a local symbol which is a section
2651   // symbol, given the relocation type.
2652   inline Relocatable_relocs::Reloc_strategy
2653   local_section_strategy(unsigned int r_type, Relobj* object)
2654   {
2655     if (sh_type == elfcpp::SHT_RELA)
2656       return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
2657     else
2658       {
2659         switch (r_type)
2660           {
2661           case elfcpp::R_MIPS_26:
2662             return Relocatable_relocs::RELOC_SPECIAL;
2663
2664           default:
2665             return Default_scan_relocatable_relocs<sh_type, Classify_reloc>::
2666                 local_section_strategy(r_type, object);
2667           }
2668       }
2669   }
2670 };
2671
2672 // Mips_copy_relocs class.  The only difference from the base class is the
2673 // method emit_mips, which should be called instead of Copy_reloc_entry::emit.
2674 // Mips cannot convert all relocation types to dynamic relocs.  If a reloc
2675 // cannot be made dynamic, a COPY reloc is emitted.
2676
2677 template<int sh_type, int size, bool big_endian>
2678 class Mips_copy_relocs : public Copy_relocs<sh_type, size, big_endian>
2679 {
2680  public:
2681   Mips_copy_relocs()
2682     : Copy_relocs<sh_type, size, big_endian>(elfcpp::R_MIPS_COPY)
2683   { }
2684
2685   // Emit any saved relocations which turn out to be needed.  This is
2686   // called after all the relocs have been scanned.
2687   void
2688   emit_mips(Output_data_reloc<sh_type, true, size, big_endian>*,
2689             Symbol_table*, Layout*, Target_mips<size, big_endian>*);
2690
2691  private:
2692   typedef typename Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry
2693     Copy_reloc_entry;
2694
2695   // Emit this reloc if appropriate.  This is called after we have
2696   // scanned all the relocations, so we know whether we emitted a
2697   // COPY relocation for SYM_.
2698   void
2699   emit_entry(Copy_reloc_entry& entry,
2700              Output_data_reloc<sh_type, true, size, big_endian>* reloc_section,
2701              Symbol_table* symtab, Layout* layout,
2702              Target_mips<size, big_endian>* target);
2703 };
2704
2705
2706 // Return true if the symbol SYM should be considered to resolve local
2707 // to the current module, and false otherwise.  The logic is taken from
2708 // GNU ld's method _bfd_elf_symbol_refs_local_p.
2709 static bool
2710 symbol_refs_local(const Symbol* sym, bool has_dynsym_entry,
2711                   bool local_protected)
2712 {
2713   // If it's a local sym, of course we resolve locally.
2714   if (sym == NULL)
2715     return true;
2716
2717   // STV_HIDDEN or STV_INTERNAL ones must be local.
2718   if (sym->visibility() == elfcpp::STV_HIDDEN
2719       || sym->visibility() == elfcpp::STV_INTERNAL)
2720     return true;
2721
2722   // If we don't have a definition in a regular file, then we can't
2723   // resolve locally.  The sym is either undefined or dynamic.
2724   if (sym->source() != Symbol::FROM_OBJECT || sym->object()->is_dynamic()
2725       || sym->is_undefined())
2726     return false;
2727
2728   // Forced local symbols resolve locally.
2729   if (sym->is_forced_local())
2730     return true;
2731
2732   // As do non-dynamic symbols.
2733   if (!has_dynsym_entry)
2734     return true;
2735
2736   // At this point, we know the symbol is defined and dynamic.  In an
2737   // executable it must resolve locally, likewise when building symbolic
2738   // shared libraries.
2739   if (parameters->options().output_is_executable()
2740       || parameters->options().Bsymbolic())
2741     return true;
2742
2743   // Now deal with defined dynamic symbols in shared libraries.  Ones
2744   // with default visibility might not resolve locally.
2745   if (sym->visibility() == elfcpp::STV_DEFAULT)
2746     return false;
2747
2748   // STV_PROTECTED non-function symbols are local.
2749   if (sym->type() != elfcpp::STT_FUNC)
2750     return true;
2751
2752   // Function pointer equality tests may require that STV_PROTECTED
2753   // symbols be treated as dynamic symbols.  If the address of a
2754   // function not defined in an executable is set to that function's
2755   // plt entry in the executable, then the address of the function in
2756   // a shared library must also be the plt entry in the executable.
2757   return local_protected;
2758 }
2759
2760 // Return TRUE if references to this symbol always reference the symbol in this
2761 // object.
2762 static bool
2763 symbol_references_local(const Symbol* sym, bool has_dynsym_entry)
2764 {
2765   return symbol_refs_local(sym, has_dynsym_entry, false);
2766 }
2767
2768 // Return TRUE if calls to this symbol always call the version in this object.
2769 static bool
2770 symbol_calls_local(const Symbol* sym, bool has_dynsym_entry)
2771 {
2772   return symbol_refs_local(sym, has_dynsym_entry, true);
2773 }
2774
2775 // Compare GOT offsets of two symbols.
2776
2777 template<int size, bool big_endian>
2778 static bool
2779 got_offset_compare(Symbol* sym1, Symbol* sym2)
2780 {
2781   Mips_symbol<size>* mips_sym1 = Mips_symbol<size>::as_mips_sym(sym1);
2782   Mips_symbol<size>* mips_sym2 = Mips_symbol<size>::as_mips_sym(sym2);
2783   unsigned int area1 = mips_sym1->global_got_area();
2784   unsigned int area2 = mips_sym2->global_got_area();
2785   gold_assert(area1 != GGA_NONE && area1 != GGA_NONE);
2786
2787   // GGA_NORMAL entries always come before GGA_RELOC_ONLY.
2788   if (area1 != area2)
2789     return area1 < area2;
2790
2791   return mips_sym1->global_gotoffset() < mips_sym2->global_gotoffset();
2792 }
2793
2794 // This method divides dynamic symbols into symbols that have GOT entry, and
2795 // symbols that don't have GOT entry.  It also sorts symbols with the GOT entry.
2796 // Mips ABI requires that symbols with the GOT entry must be at the end of
2797 // dynamic symbol table, and the order in dynamic symbol table must match the
2798 // order in GOT.
2799
2800 template<int size, bool big_endian>
2801 static void
2802 reorder_dyn_symbols(std::vector<Symbol*>* dyn_symbols,
2803                     std::vector<Symbol*>* non_got_symbols,
2804                     std::vector<Symbol*>* got_symbols)
2805 {
2806   for (std::vector<Symbol*>::iterator p = dyn_symbols->begin();
2807        p != dyn_symbols->end();
2808        ++p)
2809     {
2810       Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(*p);
2811       if (mips_sym->global_got_area() == GGA_NORMAL
2812           || mips_sym->global_got_area() == GGA_RELOC_ONLY)
2813         got_symbols->push_back(mips_sym);
2814       else
2815         non_got_symbols->push_back(mips_sym);
2816     }
2817
2818   std::sort(got_symbols->begin(), got_symbols->end(),
2819             got_offset_compare<size, big_endian>);
2820 }
2821
2822 // Functor class for processing the global symbol table.
2823
2824 template<int size, bool big_endian>
2825 class Symbol_visitor_check_symbols
2826 {
2827  public:
2828   Symbol_visitor_check_symbols(Target_mips<size, big_endian>* target,
2829     Layout* layout, Symbol_table* symtab)
2830     : target_(target), layout_(layout), symtab_(symtab)
2831   { }
2832
2833   void
2834   operator()(Sized_symbol<size>* sym)
2835   {
2836     Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(sym);
2837     if (local_pic_function<size, big_endian>(mips_sym))
2838       {
2839         // SYM is a function that might need $25 to be valid on entry.
2840         // If we're creating a non-PIC relocatable object, mark SYM as
2841         // being PIC.  If we're creating a non-relocatable object with
2842         // non-PIC branches and jumps to SYM, make sure that SYM has an la25
2843         // stub.
2844         if (parameters->options().relocatable())
2845           {
2846             if (!parameters->options().output_is_position_independent())
2847               mips_sym->set_pic();
2848           }
2849         else if (mips_sym->has_nonpic_branches())
2850           {
2851             this->target_->la25_stub_section(layout_)
2852                 ->create_la25_stub(this->symtab_, this->target_, mips_sym);
2853           }
2854       }
2855   }
2856
2857  private:
2858   Target_mips<size, big_endian>* target_;
2859   Layout* layout_;
2860   Symbol_table* symtab_;
2861 };
2862
2863 template<int size, bool big_endian>
2864 class Target_mips : public Sized_target<size, big_endian>
2865 {
2866   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
2867   typedef Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>
2868     Reloc_section;
2869   typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>
2870     Reloca_section;
2871   typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32;
2872   typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype;
2873
2874  public:
2875   Target_mips(const Target::Target_info* info = &mips_info)
2876     : Sized_target<size, big_endian>(info), got_(NULL), gp_(NULL), plt_(NULL),
2877       got_plt_(NULL), rel_dyn_(NULL), copy_relocs_(),
2878       dyn_relocs_(), la25_stub_(NULL), mips_mach_extensions_(),
2879       mips_stubs_(NULL), ei_class_(0), mach_(0), layout_(NULL),
2880       got16_addends_(), entry_symbol_is_compressed_(false), insn32_(false)
2881   {
2882     this->add_machine_extensions();
2883   }
2884
2885   // The offset of $gp from the beginning of the .got section.
2886   static const unsigned int MIPS_GP_OFFSET = 0x7ff0;
2887
2888   // The maximum size of the GOT for it to be addressable using 16-bit
2889   // offsets from $gp.
2890   static const unsigned int MIPS_GOT_MAX_SIZE = MIPS_GP_OFFSET + 0x7fff;
2891
2892   // Make a new symbol table entry for the Mips target.
2893   Sized_symbol<size>*
2894   make_symbol() const
2895   { return new Mips_symbol<size>(); }
2896
2897   // Process the relocations to determine unreferenced sections for
2898   // garbage collection.
2899   void
2900   gc_process_relocs(Symbol_table* symtab,
2901                     Layout* layout,
2902                     Sized_relobj_file<size, big_endian>* object,
2903                     unsigned int data_shndx,
2904                     unsigned int sh_type,
2905                     const unsigned char* prelocs,
2906                     size_t reloc_count,
2907                     Output_section* output_section,
2908                     bool needs_special_offset_handling,
2909                     size_t local_symbol_count,
2910                     const unsigned char* plocal_symbols);
2911
2912   // Scan the relocations to look for symbol adjustments.
2913   void
2914   scan_relocs(Symbol_table* symtab,
2915               Layout* layout,
2916               Sized_relobj_file<size, big_endian>* object,
2917               unsigned int data_shndx,
2918               unsigned int sh_type,
2919               const unsigned char* prelocs,
2920               size_t reloc_count,
2921               Output_section* output_section,
2922               bool needs_special_offset_handling,
2923               size_t local_symbol_count,
2924               const unsigned char* plocal_symbols);
2925
2926   // Finalize the sections.
2927   void
2928   do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
2929
2930   // Relocate a section.
2931   void
2932   relocate_section(const Relocate_info<size, big_endian>*,
2933                    unsigned int sh_type,
2934                    const unsigned char* prelocs,
2935                    size_t reloc_count,
2936                    Output_section* output_section,
2937                    bool needs_special_offset_handling,
2938                    unsigned char* view,
2939                    Mips_address view_address,
2940                    section_size_type view_size,
2941                    const Reloc_symbol_changes*);
2942
2943   // Scan the relocs during a relocatable link.
2944   void
2945   scan_relocatable_relocs(Symbol_table* symtab,
2946                           Layout* layout,
2947                           Sized_relobj_file<size, big_endian>* object,
2948                           unsigned int data_shndx,
2949                           unsigned int sh_type,
2950                           const unsigned char* prelocs,
2951                           size_t reloc_count,
2952                           Output_section* output_section,
2953                           bool needs_special_offset_handling,
2954                           size_t local_symbol_count,
2955                           const unsigned char* plocal_symbols,
2956                           Relocatable_relocs*);
2957
2958   // Emit relocations for a section.
2959   void
2960   relocate_relocs(const Relocate_info<size, big_endian>*,
2961                   unsigned int sh_type,
2962                   const unsigned char* prelocs,
2963                   size_t reloc_count,
2964                   Output_section* output_section,
2965                   typename elfcpp::Elf_types<size>::Elf_Off
2966                     offset_in_output_section,
2967                   const Relocatable_relocs*,
2968                   unsigned char* view,
2969                   Mips_address view_address,
2970                   section_size_type view_size,
2971                   unsigned char* reloc_view,
2972                   section_size_type reloc_view_size);
2973
2974   // Perform target-specific processing in a relocatable link.  This is
2975   // only used if we use the relocation strategy RELOC_SPECIAL.
2976   void
2977   relocate_special_relocatable(const Relocate_info<size, big_endian>* relinfo,
2978                                unsigned int sh_type,
2979                                const unsigned char* preloc_in,
2980                                size_t relnum,
2981                                Output_section* output_section,
2982                                typename elfcpp::Elf_types<size>::Elf_Off
2983                                  offset_in_output_section,
2984                                unsigned char* view,
2985                                Mips_address view_address,
2986                                section_size_type view_size,
2987                                unsigned char* preloc_out);
2988
2989   // Return whether SYM is defined by the ABI.
2990   bool
2991   do_is_defined_by_abi(const Symbol* sym) const
2992   {
2993     return ((strcmp(sym->name(), "__gnu_local_gp") == 0)
2994             || (strcmp(sym->name(), "_gp_disp") == 0)
2995             || (strcmp(sym->name(), "___tls_get_addr") == 0));
2996   }
2997
2998   // Return the number of entries in the GOT.
2999   unsigned int
3000   got_entry_count() const
3001   {
3002     if (!this->has_got_section())
3003       return 0;
3004     return this->got_size() / (size/8);
3005   }
3006
3007   // Return the number of entries in the PLT.
3008   unsigned int
3009   plt_entry_count() const
3010   {
3011     if (this->plt_ == NULL)
3012       return 0;
3013     return this->plt_->entry_count();
3014   }
3015
3016   // Return the offset of the first non-reserved PLT entry.
3017   unsigned int
3018   first_plt_entry_offset() const
3019   { return this->plt_->first_plt_entry_offset(); }
3020
3021   // Return the size of each PLT entry.
3022   unsigned int
3023   plt_entry_size() const
3024   { return this->plt_->plt_entry_size(); }
3025
3026   // Get the GOT section, creating it if necessary.
3027   Mips_output_data_got<size, big_endian>*
3028   got_section(Symbol_table*, Layout*);
3029
3030   // Get the GOT section.
3031   Mips_output_data_got<size, big_endian>*
3032   got_section() const
3033   {
3034     gold_assert(this->got_ != NULL);
3035     return this->got_;
3036   }
3037
3038   // Get the .MIPS.stubs section, creating it if necessary.
3039   Mips_output_data_mips_stubs<size, big_endian>*
3040   mips_stubs_section(Layout* layout);
3041
3042   // Get the .MIPS.stubs section.
3043   Mips_output_data_mips_stubs<size, big_endian>*
3044   mips_stubs_section() const
3045   {
3046     gold_assert(this->mips_stubs_ != NULL);
3047     return this->mips_stubs_;
3048   }
3049
3050   // Get the LA25 stub section, creating it if necessary.
3051   Mips_output_data_la25_stub<size, big_endian>*
3052   la25_stub_section(Layout*);
3053
3054   // Get the LA25 stub section.
3055   Mips_output_data_la25_stub<size, big_endian>*
3056   la25_stub_section()
3057   {
3058     gold_assert(this->la25_stub_ != NULL);
3059     return this->la25_stub_;
3060   }
3061
3062   // Get gp value.  It has the value of .got + 0x7FF0.
3063   Mips_address
3064   gp_value() const
3065   {
3066     if (this->gp_ != NULL)
3067       return this->gp_->value();
3068     return 0;
3069   }
3070
3071   // Get gp value.  It has the value of .got + 0x7FF0.  Adjust it for
3072   // multi-GOT links so that OBJECT's GOT + 0x7FF0 is returned.
3073   Mips_address
3074   adjusted_gp_value(const Mips_relobj<size, big_endian>* object)
3075   {
3076     if (this->gp_ == NULL)
3077       return 0;
3078
3079     bool multi_got = false;
3080     if (this->has_got_section())
3081       multi_got = this->got_section()->multi_got();
3082     if (!multi_got)
3083       return this->gp_->value();
3084     else
3085       return this->gp_->value() + this->got_section()->get_got_offset(object);
3086   }
3087
3088   // Get the dynamic reloc section, creating it if necessary.
3089   Reloc_section*
3090   rel_dyn_section(Layout*);
3091
3092   bool
3093   do_has_custom_set_dynsym_indexes() const
3094   { return true; }
3095
3096   // Don't emit input .reginfo sections to output .reginfo.
3097   bool
3098   do_should_include_section(elfcpp::Elf_Word sh_type) const
3099   { return sh_type != elfcpp::SHT_MIPS_REGINFO; }
3100
3101   // Set the dynamic symbol indexes.  INDEX is the index of the first
3102   // global dynamic symbol.  Pointers to the symbols are stored into the
3103   // vector SYMS.  The names are added to DYNPOOL.  This returns an
3104   // updated dynamic symbol index.
3105   unsigned int
3106   do_set_dynsym_indexes(std::vector<Symbol*>* dyn_symbols, unsigned int index,
3107                         std::vector<Symbol*>* syms, Stringpool* dynpool,
3108                         Versions* versions, Symbol_table* symtab) const;
3109
3110   // Remove .MIPS.stubs entry for a symbol.
3111   void
3112   remove_lazy_stub_entry(Mips_symbol<size>* sym)
3113   {
3114     if (this->mips_stubs_ != NULL)
3115       this->mips_stubs_->remove_entry(sym);
3116   }
3117
3118   // The value to write into got[1] for SVR4 targets, to identify it is
3119   // a GNU object.  The dynamic linker can then use got[1] to store the
3120   // module pointer.
3121   uint64_t
3122   mips_elf_gnu_got1_mask()
3123   {
3124     if (this->is_output_n64())
3125       return (uint64_t)1 << 63;
3126     else
3127       return 1 << 31;
3128   }
3129
3130   // Whether the output has microMIPS code.  This is valid only after
3131   // merge_processor_specific_flags() is called.
3132   bool
3133   is_output_micromips() const
3134   {
3135     gold_assert(this->are_processor_specific_flags_set());
3136     return elfcpp::is_micromips(this->processor_specific_flags());
3137   }
3138
3139   // Whether the output uses N32 ABI.  This is valid only after
3140   // merge_processor_specific_flags() is called.
3141   bool
3142   is_output_n32() const
3143   {
3144     gold_assert(this->are_processor_specific_flags_set());
3145     return elfcpp::abi_n32(this->processor_specific_flags());
3146   }
3147
3148   // Whether the output uses N64 ABI.  This is valid only after
3149   // merge_processor_specific_flags() is called.
3150   bool
3151   is_output_n64() const
3152   {
3153     gold_assert(this->are_processor_specific_flags_set());
3154     return elfcpp::abi_64(this->ei_class_);
3155   }
3156
3157   // Whether the output uses NEWABI.  This is valid only after
3158   // merge_processor_specific_flags() is called.
3159   bool
3160   is_output_newabi() const
3161   { return this->is_output_n32() || this->is_output_n64(); }
3162
3163   // Whether we can only use 32-bit microMIPS instructions.
3164   bool
3165   use_32bit_micromips_instructions() const
3166   { return this->insn32_; }
3167
3168  protected:
3169   // Return the value to use for a dynamic symbol which requires special
3170   // treatment.  This is how we support equality comparisons of function
3171   // pointers across shared library boundaries, as described in the
3172   // processor specific ABI supplement.
3173   uint64_t
3174   do_dynsym_value(const Symbol* gsym) const;
3175
3176   // Make an ELF object.
3177   Object*
3178   do_make_elf_object(const std::string&, Input_file*, off_t,
3179                      const elfcpp::Ehdr<size, big_endian>& ehdr);
3180
3181   Object*
3182   do_make_elf_object(const std::string&, Input_file*, off_t,
3183                      const elfcpp::Ehdr<size, !big_endian>&)
3184   { gold_unreachable(); }
3185
3186   // Make an output section.
3187   Output_section*
3188   do_make_output_section(const char* name, elfcpp::Elf_Word type,
3189                          elfcpp::Elf_Xword flags)
3190     {
3191       if (type == elfcpp::SHT_MIPS_REGINFO)
3192         return new Mips_output_section_reginfo<size, big_endian>(name, type,
3193                                                                  flags, this);
3194       else
3195         return new Output_section(name, type, flags);
3196     }
3197
3198   // Adjust ELF file header.
3199   void
3200   do_adjust_elf_header(unsigned char* view, int len);
3201
3202   // Get the custom dynamic tag value.
3203   unsigned int
3204   do_dynamic_tag_custom_value(elfcpp::DT) const;
3205
3206   // Adjust the value written to the dynamic symbol table.
3207   virtual void
3208   do_adjust_dyn_symbol(const Symbol* sym, unsigned char* view) const
3209   {
3210     elfcpp::Sym<size, big_endian> isym(view);
3211     elfcpp::Sym_write<size, big_endian> osym(view);
3212     const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(sym);
3213
3214     // Keep dynamic compressed symbols odd.  This allows the dynamic linker
3215     // to treat compressed symbols like any other.
3216     Mips_address value = isym.get_st_value();
3217     if (mips_sym->is_mips16() && value != 0)
3218       {
3219         if (!mips_sym->has_mips16_fn_stub())
3220           value |= 1;
3221         else
3222           {
3223             // If we have a MIPS16 function with a stub, the dynamic symbol
3224             // must refer to the stub, since only the stub uses the standard
3225             // calling conventions.  Stub contains MIPS32 code, so don't add +1
3226             // in this case.
3227
3228             // There is a code which does this in the method
3229             // Target_mips::do_dynsym_value, but that code will only be
3230             // executed if the symbol is from dynobj.
3231             // TODO(sasa): GNU ld also changes the value in non-dynamic symbol
3232             // table.
3233
3234             Mips16_stub_section<size, big_endian>* fn_stub =
3235               mips_sym->template get_mips16_fn_stub<big_endian>();
3236             value = fn_stub->output_address();
3237             osym.put_st_size(fn_stub->section_size());
3238           }
3239
3240         osym.put_st_value(value);
3241         osym.put_st_other(elfcpp::elf_st_other(sym->visibility(),
3242                           mips_sym->nonvis() - (elfcpp::STO_MIPS16 >> 2)));
3243       }
3244     else if ((mips_sym->is_micromips()
3245               // Stubs are always microMIPS if there is any microMIPS code in
3246               // the output.
3247               || (this->is_output_micromips() && mips_sym->has_lazy_stub()))
3248              && value != 0)
3249       {
3250         osym.put_st_value(value | 1);
3251         osym.put_st_other(elfcpp::elf_st_other(sym->visibility(),
3252                           mips_sym->nonvis() - (elfcpp::STO_MICROMIPS >> 2)));
3253       }
3254   }
3255
3256  private:
3257   // The class which scans relocations.
3258   class Scan
3259   {
3260    public:
3261     Scan()
3262     { }
3263
3264     static inline int
3265     get_reference_flags(unsigned int r_type);
3266
3267     inline void
3268     local(Symbol_table* symtab, Layout* layout, Target_mips* target,
3269           Sized_relobj_file<size, big_endian>* object,
3270           unsigned int data_shndx,
3271           Output_section* output_section,
3272           const elfcpp::Rel<size, big_endian>& reloc, unsigned int r_type,
3273           const elfcpp::Sym<size, big_endian>& lsym,
3274           bool is_discarded);
3275
3276     inline void
3277     local(Symbol_table* symtab, Layout* layout, Target_mips* target,
3278           Sized_relobj_file<size, big_endian>* object,
3279           unsigned int data_shndx,
3280           Output_section* output_section,
3281           const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
3282           const elfcpp::Sym<size, big_endian>& lsym,
3283           bool is_discarded);
3284
3285     inline void
3286     local(Symbol_table* symtab, Layout* layout, Target_mips* target,
3287           Sized_relobj_file<size, big_endian>* object,
3288           unsigned int data_shndx,
3289           Output_section* output_section,
3290           const elfcpp::Rela<size, big_endian>* rela,
3291           const elfcpp::Rel<size, big_endian>* rel,
3292           unsigned int rel_type,
3293           unsigned int r_type,
3294           const elfcpp::Sym<size, big_endian>& lsym,
3295           bool is_discarded);
3296
3297     inline void
3298     global(Symbol_table* symtab, Layout* layout, Target_mips* target,
3299            Sized_relobj_file<size, big_endian>* object,
3300            unsigned int data_shndx,
3301            Output_section* output_section,
3302            const elfcpp::Rel<size, big_endian>& reloc, unsigned int r_type,
3303            Symbol* gsym);
3304
3305     inline void
3306     global(Symbol_table* symtab, Layout* layout, Target_mips* target,
3307            Sized_relobj_file<size, big_endian>* object,
3308            unsigned int data_shndx,
3309            Output_section* output_section,
3310            const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
3311            Symbol* gsym);
3312
3313     inline void
3314     global(Symbol_table* symtab, Layout* layout, Target_mips* target,
3315            Sized_relobj_file<size, big_endian>* object,
3316            unsigned int data_shndx,
3317            Output_section* output_section,
3318            const elfcpp::Rela<size, big_endian>* rela,
3319            const elfcpp::Rel<size, big_endian>* rel,
3320            unsigned int rel_type,
3321            unsigned int r_type,
3322            Symbol* gsym);
3323
3324     inline bool
3325     local_reloc_may_be_function_pointer(Symbol_table* , Layout*,
3326                                         Target_mips*,
3327                                         Sized_relobj_file<size, big_endian>*,
3328                                         unsigned int,
3329                                         Output_section*,
3330                                         const elfcpp::Rel<size, big_endian>&,
3331                                         unsigned int,
3332                                         const elfcpp::Sym<size, big_endian>&)
3333     { return false; }
3334
3335     inline bool
3336     global_reloc_may_be_function_pointer(Symbol_table*, Layout*,
3337                                          Target_mips*,
3338                                          Sized_relobj_file<size, big_endian>*,
3339                                          unsigned int,
3340                                          Output_section*,
3341                                          const elfcpp::Rel<size, big_endian>&,
3342                                          unsigned int, Symbol*)
3343     { return false; }
3344
3345     inline bool
3346     local_reloc_may_be_function_pointer(Symbol_table*, Layout*,
3347                                         Target_mips*,
3348                                         Sized_relobj_file<size, big_endian>*,
3349                                         unsigned int,
3350                                         Output_section*,
3351                                         const elfcpp::Rela<size, big_endian>&,
3352                                         unsigned int,
3353                                         const elfcpp::Sym<size, big_endian>&)
3354     { return false; }
3355
3356     inline bool
3357     global_reloc_may_be_function_pointer(Symbol_table*, Layout*,
3358                                          Target_mips*,
3359                                          Sized_relobj_file<size, big_endian>*,
3360                                          unsigned int,
3361                                          Output_section*,
3362                                          const elfcpp::Rela<size, big_endian>&,
3363                                          unsigned int, Symbol*)
3364     { return false; }
3365    private:
3366     static void
3367     unsupported_reloc_local(Sized_relobj_file<size, big_endian>*,
3368                             unsigned int r_type);
3369
3370     static void
3371     unsupported_reloc_global(Sized_relobj_file<size, big_endian>*,
3372                              unsigned int r_type, Symbol*);
3373   };
3374
3375   // The class which implements relocation.
3376   class Relocate
3377   {
3378    public:
3379     Relocate()
3380     { }
3381
3382     ~Relocate()
3383     { }
3384
3385     // Return whether the R_MIPS_32 relocation needs to be applied.
3386     inline bool
3387     should_apply_r_mips_32_reloc(const Mips_symbol<size>* gsym,
3388                                  unsigned int r_type,
3389                                  Output_section* output_section,
3390                                  Target_mips* target);
3391
3392     // Do a relocation.  Return false if the caller should not issue
3393     // any warnings about this relocation.
3394     inline bool
3395     relocate(const Relocate_info<size, big_endian>*, Target_mips*,
3396              Output_section*, size_t relnum,
3397              const elfcpp::Rela<size, big_endian>*,
3398              const elfcpp::Rel<size, big_endian>*,
3399              unsigned int,
3400              unsigned int,  const Sized_symbol<size>*,
3401              const Symbol_value<size>*,
3402              unsigned char*,
3403              Mips_address,
3404              section_size_type);
3405
3406     inline bool
3407     relocate(const Relocate_info<size, big_endian>*, Target_mips*,
3408              Output_section*, size_t relnum,
3409              const elfcpp::Rel<size, big_endian>&,
3410              unsigned int, const Sized_symbol<size>*,
3411              const Symbol_value<size>*,
3412              unsigned char*,
3413              Mips_address,
3414              section_size_type);
3415
3416     inline bool
3417     relocate(const Relocate_info<size, big_endian>*, Target_mips*,
3418              Output_section*, size_t relnum,
3419              const elfcpp::Rela<size, big_endian>&,
3420              unsigned int, const Sized_symbol<size>*,
3421              const Symbol_value<size>*,
3422              unsigned char*,
3423              Mips_address,
3424              section_size_type);
3425   };
3426
3427   // A class which returns the size required for a relocation type,
3428   // used while scanning relocs during a relocatable link.
3429   class Relocatable_size_for_reloc
3430   {
3431    public:
3432     unsigned int
3433     get_size_for_reloc(unsigned int, Relobj*);
3434   };
3435
3436   // This POD class holds the dynamic relocations that should be emitted instead
3437   // of R_MIPS_32, R_MIPS_REL32 and R_MIPS_64 relocations.  We will emit these
3438   // relocations if it turns out that the symbol does not have static
3439   // relocations.
3440   class Dyn_reloc
3441   {
3442    public:
3443     Dyn_reloc(Mips_symbol<size>* sym, unsigned int r_type,
3444               Mips_relobj<size, big_endian>* relobj, unsigned int shndx,
3445               Output_section* output_section, Mips_address r_offset)
3446       : sym_(sym), r_type_(r_type), relobj_(relobj),
3447         shndx_(shndx), output_section_(output_section),
3448         r_offset_(r_offset)
3449     { }
3450
3451     // Emit this reloc if appropriate.  This is called after we have
3452     // scanned all the relocations, so we know whether the symbol has
3453     // static relocations.
3454     void
3455     emit(Reloc_section* rel_dyn, Mips_output_data_got<size, big_endian>* got,
3456          Symbol_table* symtab)
3457     {
3458       if (!this->sym_->has_static_relocs())
3459         {
3460           got->record_global_got_symbol(this->sym_, this->relobj_,
3461                                         this->r_type_, true, false);
3462           if (!symbol_references_local(this->sym_,
3463                                 this->sym_->should_add_dynsym_entry(symtab)))
3464             rel_dyn->add_global(this->sym_, this->r_type_,
3465                                 this->output_section_, this->relobj_,
3466                                 this->shndx_, this->r_offset_);
3467           else
3468             rel_dyn->add_symbolless_global_addend(this->sym_, this->r_type_,
3469                                           this->output_section_, this->relobj_,
3470                                           this->shndx_, this->r_offset_);
3471         }
3472     }
3473
3474    private:
3475     Mips_symbol<size>* sym_;
3476     unsigned int r_type_;
3477     Mips_relobj<size, big_endian>* relobj_;
3478     unsigned int shndx_;
3479     Output_section* output_section_;
3480     Mips_address r_offset_;
3481   };
3482
3483   // Adjust TLS relocation type based on the options and whether this
3484   // is a local symbol.
3485   static tls::Tls_optimization
3486   optimize_tls_reloc(bool is_final, int r_type);
3487
3488   // Return whether there is a GOT section.
3489   bool
3490   has_got_section() const
3491   { return this->got_ != NULL; }
3492
3493   // Check whether the given ELF header flags describe a 32-bit binary.
3494   bool
3495   mips_32bit_flags(elfcpp::Elf_Word);
3496
3497   enum Mips_mach {
3498     mach_mips3000             = 3000,
3499     mach_mips3900             = 3900,
3500     mach_mips4000             = 4000,
3501     mach_mips4010             = 4010,
3502     mach_mips4100             = 4100,
3503     mach_mips4111             = 4111,
3504     mach_mips4120             = 4120,
3505     mach_mips4300             = 4300,
3506     mach_mips4400             = 4400,
3507     mach_mips4600             = 4600,
3508     mach_mips4650             = 4650,
3509     mach_mips5000             = 5000,
3510     mach_mips5400             = 5400,
3511     mach_mips5500             = 5500,
3512     mach_mips6000             = 6000,
3513     mach_mips7000             = 7000,
3514     mach_mips8000             = 8000,
3515     mach_mips9000             = 9000,
3516     mach_mips10000            = 10000,
3517     mach_mips12000            = 12000,
3518     mach_mips14000            = 14000,
3519     mach_mips16000            = 16000,
3520     mach_mips16               = 16,
3521     mach_mips5                = 5,
3522     mach_mips_loongson_2e     = 3001,
3523     mach_mips_loongson_2f     = 3002,
3524     mach_mips_loongson_3a     = 3003,
3525     mach_mips_sb1             = 12310201, // octal 'SB', 01
3526     mach_mips_octeon          = 6501,
3527     mach_mips_octeonp         = 6601,
3528     mach_mips_octeon2         = 6502,
3529     mach_mips_xlr             = 887682,   // decimal 'XLR'
3530     mach_mipsisa32            = 32,
3531     mach_mipsisa32r2          = 33,
3532     mach_mipsisa64            = 64,
3533     mach_mipsisa64r2          = 65,
3534     mach_mips_micromips       = 96
3535   };
3536
3537   // Return the MACH for a MIPS e_flags value.
3538   unsigned int
3539   elf_mips_mach(elfcpp::Elf_Word);
3540
3541   // Check whether machine EXTENSION is an extension of machine BASE.
3542   bool
3543   mips_mach_extends(unsigned int, unsigned int);
3544
3545   // Merge processor specific flags.
3546   void
3547   merge_processor_specific_flags(const std::string&, elfcpp::Elf_Word,
3548                                  unsigned char, bool);
3549
3550   // True if we are linking for CPUs that are faster if JAL is converted to BAL.
3551   static inline bool
3552   jal_to_bal()
3553   { return false; }
3554
3555   // True if we are linking for CPUs that are faster if JALR is converted to
3556   // BAL.  This should be safe for all architectures.  We enable this predicate
3557   // for all CPUs.
3558   static inline bool
3559   jalr_to_bal()
3560   { return true; }
3561
3562   // True if we are linking for CPUs that are faster if JR is converted to B.
3563   // This should be safe for all architectures.  We enable this predicate for
3564   // all CPUs.
3565   static inline bool
3566   jr_to_b()
3567   { return true; }
3568
3569   // Return the size of the GOT section.
3570   section_size_type
3571   got_size() const
3572   {
3573     gold_assert(this->got_ != NULL);
3574     return this->got_->data_size();
3575   }
3576
3577   // Create a PLT entry for a global symbol referenced by r_type relocation.
3578   void
3579   make_plt_entry(Symbol_table*, Layout*, Mips_symbol<size>*,
3580                  unsigned int r_type);
3581
3582   // Get the PLT section.
3583   Mips_output_data_plt<size, big_endian>*
3584   plt_section() const
3585   {
3586     gold_assert(this->plt_ != NULL);
3587     return this->plt_;
3588   }
3589
3590   // Get the GOT PLT section.
3591   const Mips_output_data_plt<size, big_endian>*
3592   got_plt_section() const
3593   {
3594     gold_assert(this->got_plt_ != NULL);
3595     return this->got_plt_;
3596   }
3597
3598   // Copy a relocation against a global symbol.
3599   void
3600   copy_reloc(Symbol_table* symtab, Layout* layout,
3601              Sized_relobj_file<size, big_endian>* object,
3602              unsigned int shndx, Output_section* output_section,
3603              Symbol* sym, const elfcpp::Rel<size, big_endian>& reloc)
3604   {
3605     unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info());
3606     this->copy_relocs_.copy_reloc(symtab, layout,
3607                                   symtab->get_sized_symbol<size>(sym),
3608                                   object, shndx, output_section,
3609                                   r_type, reloc.get_r_offset(), 0,
3610                                   this->rel_dyn_section(layout));
3611   }
3612
3613   void
3614   dynamic_reloc(Mips_symbol<size>* sym, unsigned int r_type,
3615                 Mips_relobj<size, big_endian>* relobj,
3616                 unsigned int shndx, Output_section* output_section,
3617                 Mips_address r_offset)
3618   {
3619     this->dyn_relocs_.push_back(Dyn_reloc(sym, r_type, relobj, shndx,
3620                                           output_section, r_offset));
3621   }
3622
3623   // Calculate value of _gp symbol.
3624   void
3625   set_gp(Layout*, Symbol_table*);
3626
3627   const char*
3628   elf_mips_abi_name(elfcpp::Elf_Word e_flags, unsigned char ei_class);
3629   const char*
3630   elf_mips_mach_name(elfcpp::Elf_Word e_flags);
3631
3632   // Adds entries that describe how machines relate to one another.  The entries
3633   // are ordered topologically with MIPS I extensions listed last.  First
3634   // element is extension, second element is base.
3635   void
3636   add_machine_extensions()
3637   {
3638     // MIPS64r2 extensions.
3639     this->add_extension(mach_mips_octeon2, mach_mips_octeonp);
3640     this->add_extension(mach_mips_octeonp, mach_mips_octeon);
3641     this->add_extension(mach_mips_octeon, mach_mipsisa64r2);
3642
3643     // MIPS64 extensions.
3644     this->add_extension(mach_mipsisa64r2, mach_mipsisa64);
3645     this->add_extension(mach_mips_sb1, mach_mipsisa64);
3646     this->add_extension(mach_mips_xlr, mach_mipsisa64);
3647     this->add_extension(mach_mips_loongson_3a, mach_mipsisa64);
3648
3649     // MIPS V extensions.
3650     this->add_extension(mach_mipsisa64, mach_mips5);
3651
3652     // R10000 extensions.
3653     this->add_extension(mach_mips12000, mach_mips10000);
3654     this->add_extension(mach_mips14000, mach_mips10000);
3655     this->add_extension(mach_mips16000, mach_mips10000);
3656
3657     // R5000 extensions.  Note: the vr5500 ISA is an extension of the core
3658     // vr5400 ISA, but doesn't include the multimedia stuff.  It seems
3659     // better to allow vr5400 and vr5500 code to be merged anyway, since
3660     // many libraries will just use the core ISA.  Perhaps we could add
3661     // some sort of ASE flag if this ever proves a problem.
3662     this->add_extension(mach_mips5500, mach_mips5400);
3663     this->add_extension(mach_mips5400, mach_mips5000);
3664
3665     // MIPS IV extensions.
3666     this->add_extension(mach_mips5, mach_mips8000);
3667     this->add_extension(mach_mips10000, mach_mips8000);
3668     this->add_extension(mach_mips5000, mach_mips8000);
3669     this->add_extension(mach_mips7000, mach_mips8000);
3670     this->add_extension(mach_mips9000, mach_mips8000);
3671
3672     // VR4100 extensions.
3673     this->add_extension(mach_mips4120, mach_mips4100);
3674     this->add_extension(mach_mips4111, mach_mips4100);
3675
3676     // MIPS III extensions.
3677     this->add_extension(mach_mips_loongson_2e, mach_mips4000);
3678     this->add_extension(mach_mips_loongson_2f, mach_mips4000);
3679     this->add_extension(mach_mips8000, mach_mips4000);
3680     this->add_extension(mach_mips4650, mach_mips4000);
3681     this->add_extension(mach_mips4600, mach_mips4000);
3682     this->add_extension(mach_mips4400, mach_mips4000);
3683     this->add_extension(mach_mips4300, mach_mips4000);
3684     this->add_extension(mach_mips4100, mach_mips4000);
3685     this->add_extension(mach_mips4010, mach_mips4000);
3686
3687     // MIPS32 extensions.
3688     this->add_extension(mach_mipsisa32r2, mach_mipsisa32);
3689
3690     // MIPS II extensions.
3691     this->add_extension(mach_mips4000, mach_mips6000);
3692     this->add_extension(mach_mipsisa32, mach_mips6000);
3693
3694     // MIPS I extensions.
3695     this->add_extension(mach_mips6000, mach_mips3000);
3696     this->add_extension(mach_mips3900, mach_mips3000);
3697   }
3698
3699   // Add value to MIPS extenstions.
3700   void
3701   add_extension(unsigned int base, unsigned int extension)
3702   {
3703     std::pair<unsigned int, unsigned int> ext(base, extension);
3704     this->mips_mach_extensions_.push_back(ext);
3705   }
3706
3707   // Return the number of entries in the .dynsym section.
3708   unsigned int get_dt_mips_symtabno() const
3709   {
3710     return ((unsigned int)(this->layout_->dynsym_section()->data_size()
3711                            / elfcpp::Elf_sizes<size>::sym_size));
3712     // TODO(sasa): Entry size is MIPS_ELF_SYM_SIZE.
3713   }
3714
3715   // Information about this specific target which we pass to the
3716   // general Target structure.
3717   static const Target::Target_info mips_info;
3718   // The GOT section.
3719   Mips_output_data_got<size, big_endian>* got_;
3720   // gp symbol.  It has the value of .got + 0x7FF0.
3721   Sized_symbol<size>* gp_;
3722   // The PLT section.
3723   Mips_output_data_plt<size, big_endian>* plt_;
3724   // The GOT PLT section.
3725   Output_data_space* got_plt_;
3726   // The dynamic reloc section.
3727   Reloc_section* rel_dyn_;
3728   // Relocs saved to avoid a COPY reloc.
3729   Mips_copy_relocs<elfcpp::SHT_REL, size, big_endian> copy_relocs_;
3730
3731   // A list of dyn relocs to be saved.
3732   std::vector<Dyn_reloc> dyn_relocs_;
3733
3734   // The LA25 stub section.
3735   Mips_output_data_la25_stub<size, big_endian>* la25_stub_;
3736   // Architecture extensions.
3737   std::vector<std::pair<unsigned int, unsigned int> > mips_mach_extensions_;
3738   // .MIPS.stubs
3739   Mips_output_data_mips_stubs<size, big_endian>* mips_stubs_;
3740
3741   unsigned char ei_class_;
3742   unsigned int mach_;
3743   Layout* layout_;
3744
3745   typename std::list<got16_addend<size, big_endian> > got16_addends_;
3746
3747   // Whether the entry symbol is mips16 or micromips.
3748   bool entry_symbol_is_compressed_;
3749
3750   // Whether we can use only 32-bit microMIPS instructions.
3751   // TODO(sasa): This should be a linker option.
3752   bool insn32_;
3753 };
3754
3755
3756 // Helper structure for R_MIPS*_HI16/LO16 and R_MIPS*_GOT16/LO16 relocations.
3757 // It records high part of the relocation pair.
3758
3759 template<int size, bool big_endian>
3760 struct reloc_high
3761 {
3762   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
3763
3764   reloc_high(unsigned char* _view, const Mips_relobj<size, big_endian>* _object,
3765              const Symbol_value<size>* _psymval, Mips_address _addend,
3766              unsigned int _r_type, unsigned int _r_sym, bool _extract_addend,
3767              Mips_address _address = 0, bool _gp_disp = false)
3768     : view(_view), object(_object), psymval(_psymval), addend(_addend),
3769       r_type(_r_type), r_sym(_r_sym), extract_addend(_extract_addend),
3770       address(_address), gp_disp(_gp_disp)
3771   { }
3772
3773   unsigned char* view;
3774   const Mips_relobj<size, big_endian>* object;
3775   const Symbol_value<size>* psymval;
3776   Mips_address addend;
3777   unsigned int r_type;
3778   unsigned int r_sym;
3779   bool extract_addend;
3780   Mips_address address;
3781   bool gp_disp;
3782 };
3783
3784 template<int size, bool big_endian>
3785 class Mips_relocate_functions : public Relocate_functions<size, big_endian>
3786 {
3787   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
3788   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype16;
3789   typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32;
3790
3791  public:
3792   typedef enum
3793   {
3794     STATUS_OKAY,        // No error during relocation.
3795     STATUS_OVERFLOW,    // Relocation overflow.
3796     STATUS_BAD_RELOC    // Relocation cannot be applied.
3797   } Status;
3798
3799  private:
3800   typedef Relocate_functions<size, big_endian> Base;
3801   typedef Mips_relocate_functions<size, big_endian> This;
3802
3803   static typename std::list<reloc_high<size, big_endian> > hi16_relocs;
3804   static typename std::list<reloc_high<size, big_endian> > got16_relocs;
3805
3806   //   R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3807   //   Most mips16 instructions are 16 bits, but these instructions
3808   //   are 32 bits.
3809   //
3810   //   The format of these instructions is:
3811   //
3812   //   +--------------+--------------------------------+
3813   //   |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
3814   //   +--------------+--------------------------------+
3815   //   |                Immediate  15:0                |
3816   //   +-----------------------------------------------+
3817   //
3818   //   JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
3819   //   Note that the immediate value in the first word is swapped.
3820   //
3821   //   When producing a relocatable object file, R_MIPS16_26 is
3822   //   handled mostly like R_MIPS_26.  In particular, the addend is
3823   //   stored as a straight 26-bit value in a 32-bit instruction.
3824   //   (gas makes life simpler for itself by never adjusting a
3825   //   R_MIPS16_26 reloc to be against a section, so the addend is
3826   //   always zero).  However, the 32 bit instruction is stored as 2
3827   //   16-bit values, rather than a single 32-bit value.  In a
3828   //   big-endian file, the result is the same; in a little-endian
3829   //   file, the two 16-bit halves of the 32 bit value are swapped.
3830   //   This is so that a disassembler can recognize the jal
3831   //   instruction.
3832   //
3833   //   When doing a final link, R_MIPS16_26 is treated as a 32 bit
3834   //   instruction stored as two 16-bit values.  The addend A is the
3835   //   contents of the targ26 field.  The calculation is the same as
3836   //   R_MIPS_26.  When storing the calculated value, reorder the
3837   //   immediate value as shown above, and don't forget to store the
3838   //   value as two 16-bit values.
3839   //
3840   //   To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3841   //   defined as
3842   //
3843   //   big-endian:
3844   //   +--------+----------------------+
3845   //   |        |                      |
3846   //   |        |    targ26-16         |
3847   //   |31    26|25                   0|
3848   //   +--------+----------------------+
3849   //
3850   //   little-endian:
3851   //   +----------+------+-------------+
3852   //   |          |      |             |
3853   //   |  sub1    |      |     sub2    |
3854   //   |0        9|10  15|16         31|
3855   //   +----------+--------------------+
3856   //   where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3857   //   ((sub1 << 16) | sub2)).
3858   //
3859   //   When producing a relocatable object file, the calculation is
3860   //   (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3861   //   When producing a fully linked file, the calculation is
3862   //   let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3863   //   ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
3864   //
3865   //   The table below lists the other MIPS16 instruction relocations.
3866   //   Each one is calculated in the same way as the non-MIPS16 relocation
3867   //   given on the right, but using the extended MIPS16 layout of 16-bit
3868   //   immediate fields:
3869   //
3870   //      R_MIPS16_GPREL          R_MIPS_GPREL16
3871   //      R_MIPS16_GOT16          R_MIPS_GOT16
3872   //      R_MIPS16_CALL16         R_MIPS_CALL16
3873   //      R_MIPS16_HI16           R_MIPS_HI16
3874   //      R_MIPS16_LO16           R_MIPS_LO16
3875   //
3876   //   A typical instruction will have a format like this:
3877   //
3878   //   +--------------+--------------------------------+
3879   //   |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
3880   //   +--------------+--------------------------------+
3881   //   |    Major     |   rx   |   ry   |   Imm  4:0   |
3882   //   +--------------+--------------------------------+
3883   //
3884   //   EXTEND is the five bit value 11110.  Major is the instruction
3885   //   opcode.
3886   //
3887   //   All we need to do here is shuffle the bits appropriately.
3888   //   As above, the two 16-bit halves must be swapped on a
3889   //   little-endian system.
3890
3891   // Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
3892   // on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
3893   // and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.
3894
3895   static inline bool
3896   should_shuffle_micromips_reloc(unsigned int r_type)
3897   {
3898     return (micromips_reloc(r_type)
3899             && r_type != elfcpp::R_MICROMIPS_PC7_S1
3900             && r_type != elfcpp::R_MICROMIPS_PC10_S1);
3901   }
3902
3903   static void
3904   mips_reloc_unshuffle(unsigned char* view, unsigned int r_type,
3905                        bool jal_shuffle)
3906   {
3907     if (!mips16_reloc(r_type)
3908         && !should_shuffle_micromips_reloc(r_type))
3909       return;
3910
3911     // Pick up the first and second halfwords of the instruction.
3912     Valtype16 first = elfcpp::Swap<16, big_endian>::readval(view);
3913     Valtype16 second = elfcpp::Swap<16, big_endian>::readval(view + 2);
3914     Valtype32 val;
3915
3916     if (micromips_reloc(r_type)
3917         || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle))
3918       val = first << 16 | second;
3919     else if (r_type != elfcpp::R_MIPS16_26)
3920       val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
3921              | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
3922     else
3923       val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
3924              | ((first & 0x1f) << 21) | second);
3925
3926     elfcpp::Swap<32, big_endian>::writeval(view, val);
3927   }
3928
3929   static void
3930   mips_reloc_shuffle(unsigned char* view, unsigned int r_type, bool jal_shuffle)
3931   {
3932     if (!mips16_reloc(r_type)
3933         && !should_shuffle_micromips_reloc(r_type))
3934       return;
3935
3936     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
3937     Valtype16 first, second;
3938
3939     if (micromips_reloc(r_type)
3940         || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle))
3941       {
3942         second = val & 0xffff;
3943         first = val >> 16;
3944       }
3945     else if (r_type != elfcpp::R_MIPS16_26)
3946       {
3947         second = ((val >> 11) & 0xffe0) | (val & 0x1f);
3948         first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
3949       }
3950     else
3951       {
3952         second = val & 0xffff;
3953         first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
3954                  | ((val >> 21) & 0x1f);
3955       }
3956
3957     elfcpp::Swap<16, big_endian>::writeval(view + 2, second);
3958     elfcpp::Swap<16, big_endian>::writeval(view, first);
3959   }
3960
3961  public:
3962   // R_MIPS_16: S + sign-extend(A)
3963   static inline typename This::Status
3964   rel16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
3965         const Symbol_value<size>* psymval, Mips_address addend_a,
3966         bool extract_addend, unsigned int r_type)
3967   {
3968     mips_reloc_unshuffle(view, r_type, false);
3969     Valtype16* wv = reinterpret_cast<Valtype16*>(view);
3970     Valtype16 val = elfcpp::Swap<16, big_endian>::readval(wv);
3971
3972     Valtype32 addend = (extract_addend ? Bits<16>::sign_extend32(val)
3973                                        : Bits<16>::sign_extend32(addend_a));
3974
3975     Valtype32 x = psymval->value(object, addend);
3976     val = Bits<16>::bit_select32(val, x, 0xffffU);
3977     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3978     mips_reloc_shuffle(view, r_type, false);
3979     return (Bits<16>::has_overflow32(x)
3980             ? This::STATUS_OVERFLOW
3981             : This::STATUS_OKAY);
3982   }
3983
3984   // R_MIPS_32: S + A
3985   static inline typename This::Status
3986   rel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
3987         const Symbol_value<size>* psymval, Mips_address addend_a,
3988         bool extract_addend, unsigned int r_type)
3989   {
3990     mips_reloc_unshuffle(view, r_type, false);
3991     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
3992     Valtype32 addend = (extract_addend
3993                         ? elfcpp::Swap<32, big_endian>::readval(wv)
3994                         : Bits<32>::sign_extend32(addend_a));
3995     Valtype32 x = psymval->value(object, addend);
3996     elfcpp::Swap<32, big_endian>::writeval(wv, x);
3997     mips_reloc_shuffle(view, r_type, false);
3998     return This::STATUS_OKAY;
3999   }
4000
4001   // R_MIPS_JALR, R_MICROMIPS_JALR
4002   static inline typename This::Status
4003   reljalr(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4004           const Symbol_value<size>* psymval, Mips_address address,
4005           Mips_address addend_a, bool extract_addend, bool cross_mode_jump,
4006           unsigned int r_type, bool jalr_to_bal, bool jr_to_b)
4007   {
4008     mips_reloc_unshuffle(view, r_type, false);
4009     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4010     Valtype32 addend = extract_addend ? 0 : addend_a;
4011     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4012
4013     // Try converting J(AL)R to B(AL), if the target is in range.
4014     if (!parameters->options().relocatable()
4015         && r_type == elfcpp::R_MIPS_JALR
4016         && !cross_mode_jump
4017         && ((jalr_to_bal && val == 0x0320f809)    // jalr t9
4018             || (jr_to_b && val == 0x03200008)))   // jr t9
4019       {
4020         int offset = psymval->value(object, addend) - (address + 4);
4021         if (!Bits<18>::has_overflow32(offset))
4022           {
4023             if (val == 0x03200008)   // jr t9
4024               val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff);  // b addr
4025             else
4026               val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr
4027           }
4028       }
4029
4030     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4031     mips_reloc_shuffle(view, r_type, false);
4032     return This::STATUS_OKAY;
4033   }
4034
4035   // R_MIPS_PC32: S + A - P
4036   static inline typename This::Status
4037   relpc32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4038           const Symbol_value<size>* psymval, Mips_address address,
4039           Mips_address addend_a, bool extract_addend, unsigned int r_type)
4040   {
4041     mips_reloc_unshuffle(view, r_type, false);
4042     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4043     Valtype32 addend = (extract_addend
4044                         ? elfcpp::Swap<32, big_endian>::readval(wv)
4045                         : Bits<32>::sign_extend32(addend_a));
4046     Valtype32 x = psymval->value(object, addend) - address;
4047     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4048     mips_reloc_shuffle(view, r_type, false);
4049     return This::STATUS_OKAY;
4050   }
4051
4052   // R_MIPS_26, R_MIPS16_26, R_MICROMIPS_26_S1
4053   static inline typename This::Status
4054   rel26(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4055         const Symbol_value<size>* psymval, Mips_address address,
4056         bool local, Mips_address addend_a, bool extract_addend,
4057         const Symbol* gsym, bool cross_mode_jump, unsigned int r_type,
4058         bool jal_to_bal)
4059   {
4060     mips_reloc_unshuffle(view, r_type, false);
4061     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4062     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4063
4064     Valtype32 addend;
4065     if (extract_addend)
4066       {
4067         if (r_type == elfcpp::R_MICROMIPS_26_S1)
4068           addend = (val & 0x03ffffff) << 1;
4069         else
4070           addend = (val & 0x03ffffff) << 2;
4071       }
4072     else
4073       addend = addend_a;
4074
4075     // Make sure the target of JALX is word-aligned.  Bit 0 must be
4076     // the correct ISA mode selector and bit 1 must be 0.
4077     if (cross_mode_jump
4078         && (psymval->value(object, 0) & 3) != (r_type == elfcpp::R_MIPS_26))
4079       {
4080         gold_warning(_("JALX to a non-word-aligned address"));
4081         mips_reloc_shuffle(view, r_type, !parameters->options().relocatable());
4082         return This::STATUS_BAD_RELOC;
4083       }
4084
4085     // Shift is 2, unusually, for microMIPS JALX.
4086     unsigned int shift =
4087         (!cross_mode_jump && r_type == elfcpp::R_MICROMIPS_26_S1) ? 1 : 2;
4088
4089     Valtype32 x;
4090     if (local)
4091       x = addend | ((address + 4) & (0xfc000000 << shift));
4092     else
4093       {
4094         if (shift == 1)
4095           x = Bits<27>::sign_extend32(addend);
4096         else
4097           x = Bits<28>::sign_extend32(addend);
4098       }
4099     x = psymval->value(object, x) >> shift;
4100
4101     if (!local && !gsym->is_weak_undefined())
4102       {
4103         if ((x >> 26) != ((address + 4) >> (26 + shift)))
4104           {
4105             gold_error(_("relocation truncated to fit: %u against '%s'"),
4106                        r_type, gsym->name());
4107             return This::STATUS_OVERFLOW;
4108           }
4109       }
4110
4111     val = Bits<32>::bit_select32(val, x, 0x03ffffff);
4112
4113     // If required, turn JAL into JALX.
4114     if (cross_mode_jump)
4115       {
4116         bool ok;
4117         Valtype32 opcode = val >> 26;
4118         Valtype32 jalx_opcode;
4119
4120         // Check to see if the opcode is already JAL or JALX.
4121         if (r_type == elfcpp::R_MIPS16_26)
4122           {
4123             ok = (opcode == 0x6) || (opcode == 0x7);
4124             jalx_opcode = 0x7;
4125           }
4126         else if (r_type == elfcpp::R_MICROMIPS_26_S1)
4127           {
4128             ok = (opcode == 0x3d) || (opcode == 0x3c);
4129             jalx_opcode = 0x3c;
4130           }
4131         else
4132           {
4133             ok = (opcode == 0x3) || (opcode == 0x1d);
4134             jalx_opcode = 0x1d;
4135           }
4136
4137         // If the opcode is not JAL or JALX, there's a problem.  We cannot
4138         // convert J or JALS to JALX.
4139         if (!ok)
4140           {
4141             gold_error(_("Unsupported jump between ISA modes; consider "
4142                          "recompiling with interlinking enabled."));
4143             return This::STATUS_BAD_RELOC;
4144           }
4145
4146         // Make this the JALX opcode.
4147         val = (val & ~(0x3f << 26)) | (jalx_opcode << 26);
4148       }
4149
4150     // Try converting JAL to BAL, if the target is in range.
4151     if (!parameters->options().relocatable()
4152         && !cross_mode_jump
4153         && ((jal_to_bal
4154             && r_type == elfcpp::R_MIPS_26
4155             && (val >> 26) == 0x3)))    // jal addr
4156       {
4157         Valtype32 dest = (x << 2) | (((address + 4) >> 28) << 28);
4158         int offset = dest - (address + 4);
4159         if (!Bits<18>::has_overflow32(offset))
4160           {
4161             if (val == 0x03200008)   // jr t9
4162               val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff);  // b addr
4163             else
4164               val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr
4165           }
4166       }
4167
4168     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4169     mips_reloc_shuffle(view, r_type, !parameters->options().relocatable());
4170     return This::STATUS_OKAY;
4171   }
4172
4173   // R_MIPS_PC16
4174   static inline typename This::Status
4175   relpc16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4176           const Symbol_value<size>* psymval, Mips_address address,
4177           Mips_address addend_a, bool extract_addend, unsigned int r_type)
4178   {
4179     mips_reloc_unshuffle(view, r_type, false);
4180     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4181     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4182
4183     Valtype32 addend = extract_addend ? (val & 0xffff) << 2 : addend_a;
4184     addend = Bits<18>::sign_extend32(addend);
4185
4186     Valtype32 x = psymval->value(object, addend) - address;
4187     val = Bits<16>::bit_select32(val, x >> 2, 0xffff);
4188     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4189     mips_reloc_shuffle(view, r_type, false);
4190     return (Bits<18>::has_overflow32(x)
4191             ? This::STATUS_OVERFLOW
4192             : This::STATUS_OKAY);
4193   }
4194
4195   // R_MICROMIPS_PC7_S1
4196   static inline typename This::Status
4197   relmicromips_pc7_s1(unsigned char* view,
4198                       const Mips_relobj<size, big_endian>* object,
4199                       const Symbol_value<size>* psymval, Mips_address address,
4200                       Mips_address addend_a, bool extract_addend,
4201                       unsigned int r_type)
4202   {
4203     mips_reloc_unshuffle(view, r_type, false);
4204     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4205     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4206
4207     Valtype32 addend = extract_addend ? (val & 0x7f) << 1 : addend_a;
4208     addend = Bits<8>::sign_extend32(addend);
4209
4210     Valtype32 x = psymval->value(object, addend) - address;
4211     val = Bits<16>::bit_select32(val, x >> 1, 0x7f);
4212     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4213     mips_reloc_shuffle(view, r_type, false);
4214     return (Bits<8>::has_overflow32(x)
4215             ? This::STATUS_OVERFLOW
4216             : This::STATUS_OKAY);
4217   }
4218
4219   // R_MICROMIPS_PC10_S1
4220   static inline typename This::Status
4221   relmicromips_pc10_s1(unsigned char* view,
4222                        const Mips_relobj<size, big_endian>* object,
4223                        const Symbol_value<size>* psymval, Mips_address address,
4224                        Mips_address addend_a, bool extract_addend,
4225                        unsigned int r_type)
4226   {
4227     mips_reloc_unshuffle(view, r_type, false);
4228     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4229     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4230
4231     Valtype32 addend = extract_addend ? (val & 0x3ff) << 1 : addend_a;
4232     addend = Bits<11>::sign_extend32(addend);
4233
4234     Valtype32 x = psymval->value(object, addend) - address;
4235     val = Bits<16>::bit_select32(val, x >> 1, 0x3ff);
4236     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4237     mips_reloc_shuffle(view, r_type, false);
4238     return (Bits<11>::has_overflow32(x)
4239             ? This::STATUS_OVERFLOW
4240             : This::STATUS_OKAY);
4241   }
4242
4243   // R_MICROMIPS_PC16_S1
4244   static inline typename This::Status
4245   relmicromips_pc16_s1(unsigned char* view,
4246                        const Mips_relobj<size, big_endian>* object,
4247                        const Symbol_value<size>* psymval, Mips_address address,
4248                        Mips_address addend_a, bool extract_addend,
4249                        unsigned int r_type)
4250   {
4251     mips_reloc_unshuffle(view, r_type, false);
4252     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4253     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4254
4255     Valtype32 addend = extract_addend ? (val & 0xffff) << 1 : addend_a;
4256     addend = Bits<17>::sign_extend32(addend);
4257
4258     Valtype32 x = psymval->value(object, addend) - address;
4259     val = Bits<16>::bit_select32(val, x >> 1, 0xffff);
4260     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4261     mips_reloc_shuffle(view, r_type, false);
4262     return (Bits<17>::has_overflow32(x)
4263             ? This::STATUS_OVERFLOW
4264             : This::STATUS_OKAY);
4265   }
4266
4267   // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
4268   static inline typename This::Status
4269   relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4270           const Symbol_value<size>* psymval, Mips_address addend,
4271           Mips_address address, bool gp_disp, unsigned int r_type,
4272           unsigned int r_sym, bool extract_addend)
4273   {
4274     // Record the relocation.  It will be resolved when we find lo16 part.
4275     hi16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval,
4276                           addend, r_type, r_sym, extract_addend, address,
4277                           gp_disp));
4278     return This::STATUS_OKAY;
4279   }
4280
4281   // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
4282   static inline typename This::Status
4283   do_relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4284              const Symbol_value<size>* psymval, Mips_address addend_hi,
4285              Mips_address address, bool is_gp_disp, unsigned int r_type,
4286              bool extract_addend, Valtype32 addend_lo,
4287              Target_mips<size, big_endian>* target)
4288   {
4289     mips_reloc_unshuffle(view, r_type, false);
4290     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4291     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4292
4293     Valtype32 addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo
4294                                        : addend_hi);
4295
4296     Valtype32 value;
4297     if (!is_gp_disp)
4298       value = psymval->value(object, addend);
4299     else
4300       {
4301         // For MIPS16 ABI code we generate this sequence
4302         //    0: li      $v0,%hi(_gp_disp)
4303         //    4: addiupc $v1,%lo(_gp_disp)
4304         //    8: sll     $v0,16
4305         //   12: addu    $v0,$v1
4306         //   14: move    $gp,$v0
4307         // So the offsets of hi and lo relocs are the same, but the
4308         // base $pc is that used by the ADDIUPC instruction at $t9 + 4.
4309         // ADDIUPC clears the low two bits of the instruction address,
4310         // so the base is ($t9 + 4) & ~3.
4311         Valtype32 gp_disp;
4312         if (r_type == elfcpp::R_MIPS16_HI16)
4313           gp_disp = (target->adjusted_gp_value(object)
4314                      - ((address + 4) & ~0x3));
4315         // The microMIPS .cpload sequence uses the same assembly
4316         // instructions as the traditional psABI version, but the
4317         // incoming $t9 has the low bit set.
4318         else if (r_type == elfcpp::R_MICROMIPS_HI16)
4319           gp_disp = target->adjusted_gp_value(object) - address - 1;
4320         else
4321           gp_disp = target->adjusted_gp_value(object) - address;
4322         value = gp_disp + addend;
4323       }
4324     Valtype32 x = ((value + 0x8000) >> 16) & 0xffff;
4325     val = Bits<32>::bit_select32(val, x, 0xffff);
4326     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4327     mips_reloc_shuffle(view, r_type, false);
4328     return (is_gp_disp && Bits<16>::has_overflow32(x)
4329             ? This::STATUS_OVERFLOW
4330             : This::STATUS_OKAY);
4331   }
4332
4333   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4334   static inline typename This::Status
4335   relgot16_local(unsigned char* view,
4336                  const Mips_relobj<size, big_endian>* object,
4337                  const Symbol_value<size>* psymval, Mips_address addend_a,
4338                  bool extract_addend, unsigned int r_type, unsigned int r_sym)
4339   {
4340     // Record the relocation.  It will be resolved when we find lo16 part.
4341     got16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval,
4342                            addend_a, r_type, r_sym, extract_addend));
4343     return This::STATUS_OKAY;
4344   }
4345
4346   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4347   static inline typename This::Status
4348   do_relgot16_local(unsigned char* view,
4349                     const Mips_relobj<size, big_endian>* object,
4350                     const Symbol_value<size>* psymval, Mips_address addend_hi,
4351                     unsigned int r_type, bool extract_addend,
4352                     Valtype32 addend_lo, Target_mips<size, big_endian>* target)
4353   {
4354     mips_reloc_unshuffle(view, r_type, false);
4355     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4356     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4357
4358     Valtype32 addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo
4359                                        : addend_hi);
4360
4361     // Find GOT page entry.
4362     Mips_address value = ((psymval->value(object, addend) + 0x8000) >> 16)
4363                           & 0xffff;
4364     value <<= 16;
4365     unsigned int got_offset =
4366       target->got_section()->get_got_page_offset(value, object);
4367
4368     // Resolve the relocation.
4369     Valtype32 x = target->got_section()->gp_offset(got_offset, object);
4370     val = Bits<32>::bit_select32(val, x, 0xffff);
4371     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4372     mips_reloc_shuffle(view, r_type, false);
4373     return (Bits<16>::has_overflow32(x)
4374             ? This::STATUS_OVERFLOW
4375             : This::STATUS_OKAY);
4376   }
4377
4378   // R_MIPS_LO16, R_MIPS16_LO16, R_MICROMIPS_LO16, R_MICROMIPS_HI0_LO16
4379   static inline typename This::Status
4380   rello16(Target_mips<size, big_endian>* target, unsigned char* view,
4381           const Mips_relobj<size, big_endian>* object,
4382           const Symbol_value<size>* psymval, Mips_address addend_a,
4383           bool extract_addend, Mips_address address, bool is_gp_disp,
4384           unsigned int r_type, unsigned int r_sym)
4385   {
4386     mips_reloc_unshuffle(view, r_type, false);
4387     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4388     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4389
4390     Valtype32 addend = (extract_addend ? Bits<16>::sign_extend32(val & 0xffff)
4391                                        : addend_a);
4392
4393     // Resolve pending R_MIPS_HI16 relocations.
4394     typename std::list<reloc_high<size, big_endian> >::iterator it =
4395       hi16_relocs.begin();
4396     while (it != hi16_relocs.end())
4397       {
4398         reloc_high<size, big_endian> hi16 = *it;
4399         if (hi16.r_sym == r_sym
4400             && is_matching_lo16_reloc(hi16.r_type, r_type))
4401           {
4402             if (do_relhi16(hi16.view, hi16.object, hi16.psymval, hi16.addend,
4403                            hi16.address, hi16.gp_disp, hi16.r_type,
4404                            hi16.extract_addend, addend, target)
4405                 == This::STATUS_OVERFLOW)
4406               return This::STATUS_OVERFLOW;
4407             it = hi16_relocs.erase(it);
4408           }
4409         else
4410           ++it;
4411       }
4412
4413     // Resolve pending local R_MIPS_GOT16 relocations.
4414     typename std::list<reloc_high<size, big_endian> >::iterator it2 =
4415       got16_relocs.begin();
4416     while (it2 != got16_relocs.end())
4417       {
4418         reloc_high<size, big_endian> got16 = *it2;
4419         if (got16.r_sym == r_sym
4420             && is_matching_lo16_reloc(got16.r_type, r_type))
4421           {
4422             if (do_relgot16_local(got16.view, got16.object, got16.psymval,
4423                                   got16.addend, got16.r_type,
4424                                   got16.extract_addend, addend,
4425                                   target) == This::STATUS_OVERFLOW)
4426               return This::STATUS_OVERFLOW;
4427             it2 = got16_relocs.erase(it2);
4428           }
4429         else
4430           ++it2;
4431       }
4432
4433     // Resolve R_MIPS_LO16 relocation.
4434     Valtype32 x;
4435     if (!is_gp_disp)
4436       x = psymval->value(object, addend);
4437     else
4438       {
4439         // See the comment for R_MIPS16_HI16 above for the reason
4440         // for this conditional.
4441         Valtype32 gp_disp;
4442         if (r_type == elfcpp::R_MIPS16_LO16)
4443           gp_disp = target->adjusted_gp_value(object) - (address & ~0x3);
4444         else if (r_type == elfcpp::R_MICROMIPS_LO16
4445                  || r_type == elfcpp::R_MICROMIPS_HI0_LO16)
4446           gp_disp = target->adjusted_gp_value(object) - address + 3;
4447         else
4448           gp_disp = target->adjusted_gp_value(object) - address + 4;
4449         // The MIPS ABI requires checking the R_MIPS_LO16 relocation
4450         // for overflow.  Relocations against _gp_disp are normally
4451         // generated from the .cpload pseudo-op.  It generates code
4452         // that normally looks like this:
4453
4454         //   lui    $gp,%hi(_gp_disp)
4455         //   addiu  $gp,$gp,%lo(_gp_disp)
4456         //   addu   $gp,$gp,$t9
4457
4458         // Here $t9 holds the address of the function being called,
4459         // as required by the MIPS ELF ABI.  The R_MIPS_LO16
4460         // relocation can easily overflow in this situation, but the
4461         // R_MIPS_HI16 relocation will handle the overflow.
4462         // Therefore, we consider this a bug in the MIPS ABI, and do
4463         // not check for overflow here.
4464         x = gp_disp + addend;
4465       }
4466     val = Bits<32>::bit_select32(val, x, 0xffff);
4467     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4468     mips_reloc_shuffle(view, r_type, false);
4469     return This::STATUS_OKAY;
4470   }
4471
4472   // R_MIPS_CALL16, R_MIPS16_CALL16, R_MICROMIPS_CALL16
4473   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4474   // R_MIPS_TLS_GD, R_MIPS16_TLS_GD, R_MICROMIPS_TLS_GD
4475   // R_MIPS_TLS_GOTTPREL, R_MIPS16_TLS_GOTTPREL, R_MICROMIPS_TLS_GOTTPREL
4476   // R_MIPS_TLS_LDM, R_MIPS16_TLS_LDM, R_MICROMIPS_TLS_LDM
4477   // R_MIPS_GOT_DISP, R_MICROMIPS_GOT_DISP
4478   static inline typename This::Status
4479   relgot(unsigned char* view, int gp_offset, unsigned int r_type)
4480   {
4481     mips_reloc_unshuffle(view, r_type, false);
4482     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4483     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4484     Valtype32 x = gp_offset;
4485     val = Bits<32>::bit_select32(val, x, 0xffff);
4486     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4487     mips_reloc_shuffle(view, r_type, false);
4488     return (Bits<16>::has_overflow32(x)
4489             ? This::STATUS_OVERFLOW
4490             : This::STATUS_OKAY);
4491   }
4492
4493   // R_MIPS_GOT_PAGE, R_MICROMIPS_GOT_PAGE
4494   static inline typename This::Status
4495   relgotpage(Target_mips<size, big_endian>* target, unsigned char* view,
4496              const Mips_relobj<size, big_endian>* object,
4497              const Symbol_value<size>* psymval, Mips_address addend_a,
4498              bool extract_addend, unsigned int r_type)
4499   {
4500     mips_reloc_unshuffle(view, r_type, false);
4501     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4502     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
4503     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4504
4505     // Find a GOT page entry that points to within 32KB of symbol + addend.
4506     Mips_address value = (psymval->value(object, addend) + 0x8000) & ~0xffff;
4507     unsigned int  got_offset =
4508       target->got_section()->get_got_page_offset(value, object);
4509
4510     Valtype32 x = target->got_section()->gp_offset(got_offset, object);
4511     val = Bits<32>::bit_select32(val, x, 0xffff);
4512     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4513     mips_reloc_shuffle(view, r_type, false);
4514     return (Bits<16>::has_overflow32(x)
4515             ? This::STATUS_OVERFLOW
4516             : This::STATUS_OKAY);
4517   }
4518
4519   // R_MIPS_GOT_OFST, R_MICROMIPS_GOT_OFST
4520   static inline typename This::Status
4521   relgotofst(Target_mips<size, big_endian>* target, unsigned char* view,
4522              const Mips_relobj<size, big_endian>* object,
4523              const Symbol_value<size>* psymval, Mips_address addend_a,
4524              bool extract_addend, bool local, unsigned int r_type)
4525   {
4526     mips_reloc_unshuffle(view, r_type, false);
4527     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4528     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
4529     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4530
4531     // For a local symbol, find a GOT page entry that points to within 32KB of
4532     // symbol + addend.  Relocation value is the offset of the GOT page entry's
4533     // value from symbol + addend.
4534     // For a global symbol, relocation value is addend.
4535     Valtype32 x;
4536     if (local)
4537       {
4538         // Find GOT page entry.
4539         Mips_address value = ((psymval->value(object, addend) + 0x8000)
4540                               & ~0xffff);
4541         target->got_section()->get_got_page_offset(value, object);
4542
4543         x = psymval->value(object, addend) - value;
4544       }
4545     else
4546       x = addend;
4547     val = Bits<32>::bit_select32(val, x, 0xffff);
4548     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4549     mips_reloc_shuffle(view, r_type, false);
4550     return (Bits<16>::has_overflow32(x)
4551             ? This::STATUS_OVERFLOW
4552             : This::STATUS_OKAY);
4553   }
4554
4555   // R_MIPS_GOT_HI16, R_MIPS_CALL_HI16,
4556   // R_MICROMIPS_GOT_HI16, R_MICROMIPS_CALL_HI16
4557   static inline typename This::Status
4558   relgot_hi16(unsigned char* view, int gp_offset, unsigned int r_type)
4559   {
4560     mips_reloc_unshuffle(view, r_type, false);
4561     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4562     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4563     Valtype32 x = gp_offset;
4564     x = ((x + 0x8000) >> 16) & 0xffff;
4565     val = Bits<32>::bit_select32(val, x, 0xffff);
4566     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4567     mips_reloc_shuffle(view, r_type, false);
4568     return This::STATUS_OKAY;
4569   }
4570
4571   // R_MIPS_GOT_LO16, R_MIPS_CALL_LO16,
4572   // R_MICROMIPS_GOT_LO16, R_MICROMIPS_CALL_LO16
4573   static inline typename This::Status
4574   relgot_lo16(unsigned char* view, int gp_offset, unsigned int r_type)
4575   {
4576     mips_reloc_unshuffle(view, r_type, false);
4577     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4578     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4579     Valtype32 x = gp_offset;
4580     val = Bits<32>::bit_select32(val, x, 0xffff);
4581     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4582     mips_reloc_shuffle(view, r_type, false);
4583     return This::STATUS_OKAY;
4584   }
4585
4586   // R_MIPS_GPREL16, R_MIPS16_GPREL, R_MIPS_LITERAL, R_MICROMIPS_LITERAL
4587   // R_MICROMIPS_GPREL7_S2, R_MICROMIPS_GPREL16
4588   static inline typename This::Status
4589   relgprel(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4590            const Symbol_value<size>* psymval, Mips_address gp,
4591            Mips_address addend_a, bool extract_addend, bool local,
4592            unsigned int r_type)
4593   {
4594     mips_reloc_unshuffle(view, r_type, false);
4595     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4596     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4597
4598     Valtype32 addend;
4599     if (extract_addend)
4600       {
4601         if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2)
4602           addend = (val & 0x7f) << 2;
4603         else
4604           addend = val & 0xffff;
4605         // Only sign-extend the addend if it was extracted from the
4606         // instruction.  If the addend was separate, leave it alone,
4607         // otherwise we may lose significant bits.
4608         addend = Bits<16>::sign_extend32(addend);
4609       }
4610     else
4611       addend = addend_a;
4612
4613     Valtype32 x = psymval->value(object, addend) - gp;
4614
4615     // If the symbol was local, any earlier relocatable links will
4616     // have adjusted its addend with the gp offset, so compensate
4617     // for that now.  Don't do it for symbols forced local in this
4618     // link, though, since they won't have had the gp offset applied
4619     // to them before.
4620     if (local)
4621       x += object->gp_value();
4622
4623     if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2)
4624       val = Bits<32>::bit_select32(val, x, 0x7f);
4625     else
4626       val = Bits<32>::bit_select32(val, x, 0xffff);
4627     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4628     mips_reloc_shuffle(view, r_type, false);
4629     if (Bits<16>::has_overflow32(x))
4630       {
4631         gold_error(_("small-data section exceeds 64KB; lower small-data size "
4632                      "limit (see option -G)"));
4633         return This::STATUS_OVERFLOW;
4634       }
4635     return This::STATUS_OKAY;
4636   }
4637
4638   // R_MIPS_GPREL32
4639   static inline typename This::Status
4640   relgprel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4641              const Symbol_value<size>* psymval, Mips_address gp,
4642              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4643   {
4644     mips_reloc_unshuffle(view, r_type, false);
4645     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4646     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4647     Valtype32 addend = extract_addend ? val : addend_a;
4648
4649     // R_MIPS_GPREL32 relocations are defined for local symbols only.
4650     Valtype32 x = psymval->value(object, addend) + object->gp_value() - gp;
4651     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4652     mips_reloc_shuffle(view, r_type, false);
4653     return This::STATUS_OKAY;
4654  }
4655
4656   // R_MIPS_TLS_TPREL_HI16, R_MIPS16_TLS_TPREL_HI16, R_MICROMIPS_TLS_TPREL_HI16
4657   // R_MIPS_TLS_DTPREL_HI16, R_MIPS16_TLS_DTPREL_HI16,
4658   // R_MICROMIPS_TLS_DTPREL_HI16
4659   static inline typename This::Status
4660   tlsrelhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4661              const Symbol_value<size>* psymval, Valtype32 tp_offset,
4662              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4663   {
4664     mips_reloc_unshuffle(view, r_type, false);
4665     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4666     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4667     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4668
4669     // tls symbol values are relative to tls_segment()->vaddr()
4670     Valtype32 x = ((psymval->value(object, addend) - tp_offset) + 0x8000) >> 16;
4671     val = Bits<32>::bit_select32(val, x, 0xffff);
4672     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4673     mips_reloc_shuffle(view, r_type, false);
4674     return This::STATUS_OKAY;
4675   }
4676
4677   // R_MIPS_TLS_TPREL_LO16, R_MIPS16_TLS_TPREL_LO16, R_MICROMIPS_TLS_TPREL_LO16,
4678   // R_MIPS_TLS_DTPREL_LO16, R_MIPS16_TLS_DTPREL_LO16,
4679   // R_MICROMIPS_TLS_DTPREL_LO16,
4680   static inline typename This::Status
4681   tlsrello16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4682              const Symbol_value<size>* psymval, Valtype32 tp_offset,
4683              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4684   {
4685     mips_reloc_unshuffle(view, r_type, false);
4686     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4687     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4688     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4689
4690     // tls symbol values are relative to tls_segment()->vaddr()
4691     Valtype32 x = psymval->value(object, addend) - tp_offset;
4692     val = Bits<32>::bit_select32(val, x, 0xffff);
4693     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4694     mips_reloc_shuffle(view, r_type, false);
4695     return This::STATUS_OKAY;
4696   }
4697
4698   // R_MIPS_TLS_TPREL32, R_MIPS_TLS_TPREL64,
4699   // R_MIPS_TLS_DTPREL32, R_MIPS_TLS_DTPREL64
4700   static inline typename This::Status
4701   tlsrel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4702            const Symbol_value<size>* psymval, Valtype32 tp_offset,
4703            Mips_address addend_a, bool extract_addend, unsigned int r_type)
4704   {
4705     mips_reloc_unshuffle(view, r_type, false);
4706     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4707     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4708     Valtype32 addend = extract_addend ? val : addend_a;
4709
4710     // tls symbol values are relative to tls_segment()->vaddr()
4711     Valtype32 x = psymval->value(object, addend) - tp_offset;
4712     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4713     mips_reloc_shuffle(view, r_type, false);
4714     return This::STATUS_OKAY;
4715   }
4716
4717   // R_MIPS_SUB, R_MICROMIPS_SUB
4718   static inline typename This::Status
4719   relsub(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4720          const Symbol_value<size>* psymval, Mips_address addend_a,
4721          bool extract_addend, unsigned int r_type)
4722   {
4723     mips_reloc_unshuffle(view, r_type, false);
4724     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4725     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4726     Valtype32 addend = extract_addend ? val : addend_a;
4727
4728     Valtype32 x = psymval->value(object, -addend);
4729     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4730     mips_reloc_shuffle(view, r_type, false);
4731     return This::STATUS_OKAY;
4732  }
4733 };
4734
4735 template<int size, bool big_endian>
4736 typename std::list<reloc_high<size, big_endian> >
4737     Mips_relocate_functions<size, big_endian>::hi16_relocs;
4738
4739 template<int size, bool big_endian>
4740 typename std::list<reloc_high<size, big_endian> >
4741     Mips_relocate_functions<size, big_endian>::got16_relocs;
4742
4743 // Mips_got_info methods.
4744
4745 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
4746 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
4747
4748 template<int size, bool big_endian>
4749 void
4750 Mips_got_info<size, big_endian>::record_local_got_symbol(
4751     Mips_relobj<size, big_endian>* object, unsigned int symndx,
4752     Mips_address addend, unsigned int r_type, unsigned int shndx)
4753 {
4754   Mips_got_entry<size, big_endian>* entry =
4755     new Mips_got_entry<size, big_endian>(object, symndx, addend,
4756                                          mips_elf_reloc_tls_type(r_type),
4757                                          shndx);
4758   this->record_got_entry(entry, object);
4759 }
4760
4761 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
4762 // in OBJECT.  FOR_CALL is true if the caller is only interested in
4763 // using the GOT entry for calls.  DYN_RELOC is true if R_TYPE is a dynamic
4764 // relocation.
4765
4766 template<int size, bool big_endian>
4767 void
4768 Mips_got_info<size, big_endian>::record_global_got_symbol(
4769     Mips_symbol<size>* mips_sym, Mips_relobj<size, big_endian>* object,
4770     unsigned int r_type, bool dyn_reloc, bool for_call)
4771 {
4772   if (!for_call)
4773     mips_sym->set_got_not_only_for_calls();
4774
4775   // A global symbol in the GOT must also be in the dynamic symbol table.
4776   if (!mips_sym->needs_dynsym_entry())
4777     {
4778       switch (mips_sym->visibility())
4779         {
4780         case elfcpp::STV_INTERNAL:
4781         case elfcpp::STV_HIDDEN:
4782           mips_sym->set_is_forced_local();
4783           break;
4784         default:
4785           mips_sym->set_needs_dynsym_entry();
4786           break;
4787         }
4788     }
4789
4790   unsigned char tls_type = mips_elf_reloc_tls_type(r_type);
4791   if (tls_type == GOT_TLS_NONE)
4792     this->global_got_symbols_.insert(mips_sym);
4793
4794   if (dyn_reloc)
4795     {
4796       if (mips_sym->global_got_area() == GGA_NONE)
4797         mips_sym->set_global_got_area(GGA_RELOC_ONLY);
4798       return;
4799     }
4800
4801   Mips_got_entry<size, big_endian>* entry =
4802     new Mips_got_entry<size, big_endian>(object, mips_sym, tls_type);
4803
4804   this->record_got_entry(entry, object);
4805 }
4806
4807 // Add ENTRY to master GOT and to OBJECT's GOT.
4808
4809 template<int size, bool big_endian>
4810 void
4811 Mips_got_info<size, big_endian>::record_got_entry(
4812     Mips_got_entry<size, big_endian>* entry,
4813     Mips_relobj<size, big_endian>* object)
4814 {
4815   if (this->got_entries_.find(entry) == this->got_entries_.end())
4816     this->got_entries_.insert(entry);
4817
4818   // Create the GOT entry for the OBJECT's GOT.
4819   Mips_got_info<size, big_endian>* g = object->get_or_create_got_info();
4820   Mips_got_entry<size, big_endian>* entry2 =
4821     new Mips_got_entry<size, big_endian>(*entry);
4822
4823   if (g->got_entries_.find(entry2) == g->got_entries_.end())
4824     g->got_entries_.insert(entry2);
4825 }
4826
4827 // Record that OBJECT has a page relocation against symbol SYMNDX and
4828 // that ADDEND is the addend for that relocation.
4829 // This function creates an upper bound on the number of GOT slots
4830 // required; no attempt is made to combine references to non-overridable
4831 // global symbols across multiple input files.
4832
4833 template<int size, bool big_endian>
4834 void
4835 Mips_got_info<size, big_endian>::record_got_page_entry(
4836     Mips_relobj<size, big_endian>* object, unsigned int symndx, int addend)
4837 {
4838   struct Got_page_range **range_ptr, *range;
4839   int old_pages, new_pages;
4840
4841   // Find the Got_page_entry for this symbol.
4842   Got_page_entry* entry = new Got_page_entry(object, symndx);
4843   typename Got_page_entry_set::iterator it =
4844     this->got_page_entries_.find(entry);
4845   if (it != this->got_page_entries_.end())
4846     entry = *it;
4847   else
4848     this->got_page_entries_.insert(entry);
4849
4850   // Add the same entry to the OBJECT's GOT.
4851   Got_page_entry* entry2 = NULL;
4852   Mips_got_info<size, big_endian>* g2 = object->get_or_create_got_info();
4853   if (g2->got_page_entries_.find(entry) == g2->got_page_entries_.end())
4854     {
4855       entry2 = new Got_page_entry(*entry);
4856       g2->got_page_entries_.insert(entry2);
4857     }
4858
4859   // Skip over ranges whose maximum extent cannot share a page entry
4860   // with ADDEND.
4861   range_ptr = &entry->ranges;
4862   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4863     range_ptr = &(*range_ptr)->next;
4864
4865   // If we scanned to the end of the list, or found a range whose
4866   // minimum extent cannot share a page entry with ADDEND, create
4867   // a new singleton range.
4868   range = *range_ptr;
4869   if (!range || addend < range->min_addend - 0xffff)
4870     {
4871       range = new Got_page_range();
4872       range->next = *range_ptr;
4873       range->min_addend = addend;
4874       range->max_addend = addend;
4875
4876       *range_ptr = range;
4877       ++entry->num_pages;
4878       if (entry2 != NULL)
4879         ++entry2->num_pages;
4880       ++this->page_gotno_;
4881       ++g2->page_gotno_;
4882       return;
4883     }
4884
4885   // Remember how many pages the old range contributed.
4886   old_pages = range->get_max_pages();
4887
4888   // Update the ranges.
4889   if (addend < range->min_addend)
4890     range->min_addend = addend;
4891   else if (addend > range->max_addend)
4892     {
4893       if (range->next && addend >= range->next->min_addend - 0xffff)
4894         {
4895           old_pages += range->next->get_max_pages();
4896           range->max_addend = range->next->max_addend;
4897           range->next = range->next->next;
4898         }
4899       else
4900         range->max_addend = addend;
4901     }
4902
4903   // Record any change in the total estimate.
4904   new_pages = range->get_max_pages();
4905   if (old_pages != new_pages)
4906     {
4907       entry->num_pages += new_pages - old_pages;
4908       if (entry2 != NULL)
4909         entry2->num_pages += new_pages - old_pages;
4910       this->page_gotno_ += new_pages - old_pages;
4911       g2->page_gotno_ += new_pages - old_pages;
4912     }
4913 }
4914
4915 // Create all entries that should be in the local part of the GOT.
4916
4917 template<int size, bool big_endian>
4918 void
4919 Mips_got_info<size, big_endian>::add_local_entries(
4920     Target_mips<size, big_endian>* target, Layout* layout)
4921 {
4922   Mips_output_data_got<size, big_endian>* got = target->got_section();
4923   // First two GOT entries are reserved.  The first entry will be filled at
4924   // runtime.  The second entry will be used by some runtime loaders.
4925   got->add_constant(0);
4926   got->add_constant(target->mips_elf_gnu_got1_mask());
4927
4928   for (typename Got_entry_set::iterator
4929        p = this->got_entries_.begin();
4930        p != this->got_entries_.end();
4931        ++p)
4932     {
4933       Mips_got_entry<size, big_endian>* entry = *p;
4934       if (entry->is_for_local_symbol() && !entry->is_tls_entry())
4935         {
4936           got->add_local(entry->object(), entry->symndx(),
4937                          GOT_TYPE_STANDARD);
4938           unsigned int got_offset = entry->object()->local_got_offset(
4939               entry->symndx(), GOT_TYPE_STANDARD);
4940           if (got->multi_got() && this->index_ > 0
4941               && parameters->options().output_is_position_independent())
4942             target->rel_dyn_section(layout)->add_local(entry->object(),
4943                 entry->symndx(), elfcpp::R_MIPS_REL32, got, got_offset);
4944         }
4945     }
4946
4947   this->add_page_entries(target, layout);
4948
4949   // Add global entries that should be in the local area.
4950   for (typename Got_entry_set::iterator
4951        p = this->got_entries_.begin();
4952        p != this->got_entries_.end();
4953        ++p)
4954     {
4955       Mips_got_entry<size, big_endian>* entry = *p;
4956       if (!entry->is_for_global_symbol())
4957         continue;
4958
4959       Mips_symbol<size>* mips_sym = entry->sym();
4960       if (mips_sym->global_got_area() == GGA_NONE && !entry->is_tls_entry())
4961         {
4962           unsigned int got_type;
4963           if (!got->multi_got())
4964             got_type = GOT_TYPE_STANDARD;
4965           else
4966             got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_;
4967           if (got->add_global(mips_sym, got_type))
4968             {
4969               mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
4970               if (got->multi_got() && this->index_ > 0
4971                   && parameters->options().output_is_position_independent())
4972                 target->rel_dyn_section(layout)->add_symbolless_global_addend(
4973                     mips_sym, elfcpp::R_MIPS_REL32, got,
4974                     mips_sym->got_offset(got_type));
4975             }
4976         }
4977     }
4978 }
4979
4980 // Create GOT page entries.
4981
4982 template<int size, bool big_endian>
4983 void
4984 Mips_got_info<size, big_endian>::add_page_entries(
4985     Target_mips<size, big_endian>* target, Layout* layout)
4986 {
4987   if (this->page_gotno_ == 0)
4988     return;
4989
4990   Mips_output_data_got<size, big_endian>* got = target->got_section();
4991   this->got_page_offset_start_ = got->add_constant(0);
4992   if (got->multi_got() && this->index_ > 0
4993       && parameters->options().output_is_position_independent())
4994     target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got,
4995                                                   this->got_page_offset_start_);
4996   int num_entries = this->page_gotno_;
4997   unsigned int prev_offset = this->got_page_offset_start_;
4998   while (--num_entries > 0)
4999     {
5000       unsigned int next_offset = got->add_constant(0);
5001       if (got->multi_got() && this->index_ > 0
5002           && parameters->options().output_is_position_independent())
5003         target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got,
5004                                                       next_offset);
5005       gold_assert(next_offset == prev_offset + size/8);
5006       prev_offset = next_offset;
5007     }
5008   this->got_page_offset_next_ = this->got_page_offset_start_;
5009 }
5010
5011 // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY.
5012
5013 template<int size, bool big_endian>
5014 void
5015 Mips_got_info<size, big_endian>::add_global_entries(
5016     Target_mips<size, big_endian>* target, Layout* layout,
5017     unsigned int non_reloc_only_global_gotno)
5018 {
5019   Mips_output_data_got<size, big_endian>* got = target->got_section();
5020   // Add GGA_NORMAL entries.
5021   unsigned int count = 0;
5022   for (typename Got_entry_set::iterator
5023        p = this->got_entries_.begin();
5024        p != this->got_entries_.end();
5025        ++p)
5026     {
5027       Mips_got_entry<size, big_endian>* entry = *p;
5028       if (!entry->is_for_global_symbol())
5029         continue;
5030
5031       Mips_symbol<size>* mips_sym = entry->sym();
5032       if (mips_sym->global_got_area() != GGA_NORMAL)
5033         continue;
5034
5035       unsigned int got_type;
5036       if (!got->multi_got())
5037         got_type = GOT_TYPE_STANDARD;
5038       else
5039         // In multi-GOT links, global symbol can be in both primary and
5040         // secondary GOT(s).  By creating custom GOT type
5041         // (GOT_TYPE_STANDARD_MULTIGOT + got_index) we ensure that symbol
5042         // is added to secondary GOT(s).
5043         got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_;
5044       if (!got->add_global(mips_sym, got_type))
5045         continue;
5046
5047       mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
5048       if (got->multi_got() && this->index_ == 0)
5049         count++;
5050       if (got->multi_got() && this->index_ > 0)
5051         {
5052           if (parameters->options().output_is_position_independent()
5053               || (!parameters->doing_static_link()
5054                   && mips_sym->is_from_dynobj() && !mips_sym->is_undefined()))
5055             {
5056               target->rel_dyn_section(layout)->add_global(
5057                   mips_sym, elfcpp::R_MIPS_REL32, got,
5058                   mips_sym->got_offset(got_type));
5059               got->add_secondary_got_reloc(mips_sym->got_offset(got_type),
5060                                            elfcpp::R_MIPS_REL32, mips_sym);
5061             }
5062         }
5063     }
5064
5065   if (!got->multi_got() || this->index_ == 0)
5066     {
5067       if (got->multi_got())
5068         {
5069           // We need to allocate space in the primary GOT for GGA_NORMAL entries
5070           // of secondary GOTs, to ensure that GOT offsets of GGA_RELOC_ONLY
5071           // entries correspond to dynamic symbol indexes.
5072           while (count < non_reloc_only_global_gotno)
5073             {
5074               got->add_constant(0);
5075               ++count;
5076             }
5077         }
5078
5079       // Add GGA_RELOC_ONLY entries.
5080       got->add_reloc_only_entries();
5081     }
5082 }
5083
5084 // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
5085
5086 template<int size, bool big_endian>
5087 void
5088 Mips_got_info<size, big_endian>::add_reloc_only_entries(
5089     Mips_output_data_got<size, big_endian>* got)
5090 {
5091   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5092        p = this->global_got_symbols_.begin();
5093        p != this->global_got_symbols_.end();
5094        ++p)
5095     {
5096       Mips_symbol<size>* mips_sym = *p;
5097       if (mips_sym->global_got_area() == GGA_RELOC_ONLY)
5098         {
5099           unsigned int got_type;
5100           if (!got->multi_got())
5101             got_type = GOT_TYPE_STANDARD;
5102           else
5103             got_type = GOT_TYPE_STANDARD_MULTIGOT;
5104           if (got->add_global(mips_sym, got_type))
5105             mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
5106         }
5107     }
5108 }
5109
5110 // Create TLS GOT entries.
5111
5112 template<int size, bool big_endian>
5113 void
5114 Mips_got_info<size, big_endian>::add_tls_entries(
5115     Target_mips<size, big_endian>* target, Layout* layout)
5116 {
5117   Mips_output_data_got<size, big_endian>* got = target->got_section();
5118   // Add local tls entries.
5119   for (typename Got_entry_set::iterator
5120        p = this->got_entries_.begin();
5121        p != this->got_entries_.end();
5122        ++p)
5123     {
5124       Mips_got_entry<size, big_endian>* entry = *p;
5125       if (!entry->is_tls_entry() || !entry->is_for_local_symbol())
5126         continue;
5127
5128       if (entry->tls_type() == GOT_TLS_GD)
5129         {
5130           unsigned int got_type = GOT_TYPE_TLS_PAIR;
5131           unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5132                                              : elfcpp::R_MIPS_TLS_DTPMOD64);
5133           unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32
5134                                              : elfcpp::R_MIPS_TLS_DTPREL64);
5135
5136           if (!parameters->doing_static_link())
5137             {
5138               got->add_local_pair_with_rel(entry->object(), entry->symndx(),
5139                                            entry->shndx(), got_type,
5140                                            target->rel_dyn_section(layout),
5141                                            r_type1);
5142               unsigned int got_offset =
5143                 entry->object()->local_got_offset(entry->symndx(), got_type);
5144               got->add_static_reloc(got_offset + size/8, r_type2,
5145                                     entry->object(), entry->symndx());
5146             }
5147           else
5148             {
5149               // We are doing a static link.  Mark it as belong to module 1,
5150               // the executable.
5151               unsigned int got_offset = got->add_constant(1);
5152               entry->object()->set_local_got_offset(entry->symndx(), got_type,
5153                                                     got_offset);
5154               got->add_constant(0);
5155               got->add_static_reloc(got_offset + size/8, r_type2,
5156                                     entry->object(), entry->symndx());
5157             }
5158         }
5159       else if (entry->tls_type() == GOT_TLS_IE)
5160         {
5161           unsigned int got_type = GOT_TYPE_TLS_OFFSET;
5162           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32
5163                                             : elfcpp::R_MIPS_TLS_TPREL64);
5164           if (!parameters->doing_static_link())
5165             got->add_local_with_rel(entry->object(), entry->symndx(), got_type,
5166                                     target->rel_dyn_section(layout), r_type);
5167           else
5168             {
5169               got->add_local(entry->object(), entry->symndx(), got_type);
5170               unsigned int got_offset =
5171                   entry->object()->local_got_offset(entry->symndx(), got_type);
5172               got->add_static_reloc(got_offset, r_type, entry->object(),
5173                                     entry->symndx());
5174             }
5175         }
5176       else if (entry->tls_type() == GOT_TLS_LDM)
5177         {
5178           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5179                                             : elfcpp::R_MIPS_TLS_DTPMOD64);
5180           unsigned int got_offset;
5181           if (!parameters->doing_static_link())
5182             {
5183               got_offset = got->add_constant(0);
5184               target->rel_dyn_section(layout)->add_local(
5185                   entry->object(), 0, r_type, got, got_offset);
5186             }
5187           else
5188             // We are doing a static link.  Just mark it as belong to module 1,
5189             // the executable.
5190             got_offset = got->add_constant(1);
5191
5192           got->add_constant(0);
5193           got->set_tls_ldm_offset(got_offset, entry->object());
5194         }
5195       else
5196         gold_unreachable();
5197     }
5198
5199   // Add global tls entries.
5200   for (typename Got_entry_set::iterator
5201        p = this->got_entries_.begin();
5202        p != this->got_entries_.end();
5203        ++p)
5204     {
5205       Mips_got_entry<size, big_endian>* entry = *p;
5206       if (!entry->is_tls_entry() || !entry->is_for_global_symbol())
5207         continue;
5208
5209       Mips_symbol<size>* mips_sym = entry->sym();
5210       if (entry->tls_type() == GOT_TLS_GD)
5211         {
5212           unsigned int got_type;
5213           if (!got->multi_got())
5214             got_type = GOT_TYPE_TLS_PAIR;
5215           else
5216             got_type = GOT_TYPE_TLS_PAIR_MULTIGOT + this->index_;
5217           unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5218                                              : elfcpp::R_MIPS_TLS_DTPMOD64);
5219           unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32
5220                                              : elfcpp::R_MIPS_TLS_DTPREL64);
5221           if (!parameters->doing_static_link())
5222             got->add_global_pair_with_rel(mips_sym, got_type,
5223                              target->rel_dyn_section(layout), r_type1, r_type2);
5224           else
5225             {
5226               // Add a GOT pair for for R_MIPS_TLS_GD.  The creates a pair of
5227               // GOT entries.  The first one is initialized to be 1, which is the
5228               // module index for the main executable and the second one 0.  A
5229               // reloc of the type R_MIPS_TLS_DTPREL32/64 will be created for
5230               // the second GOT entry and will be applied by gold.
5231               unsigned int got_offset = got->add_constant(1);
5232               mips_sym->set_got_offset(got_type, got_offset);
5233               got->add_constant(0);
5234               got->add_static_reloc(got_offset + size/8, r_type2, mips_sym);
5235             }
5236         }
5237       else if (entry->tls_type() == GOT_TLS_IE)
5238         {
5239           unsigned int got_type;
5240           if (!got->multi_got())
5241             got_type = GOT_TYPE_TLS_OFFSET;
5242           else
5243             got_type = GOT_TYPE_TLS_OFFSET_MULTIGOT + this->index_;
5244           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32
5245                                             : elfcpp::R_MIPS_TLS_TPREL64);
5246           if (!parameters->doing_static_link())
5247             got->add_global_with_rel(mips_sym, got_type,
5248                                      target->rel_dyn_section(layout), r_type);
5249           else
5250             {
5251               got->add_global(mips_sym, got_type);
5252               unsigned int got_offset = mips_sym->got_offset(got_type);
5253               got->add_static_reloc(got_offset, r_type, mips_sym);
5254             }
5255         }
5256       else
5257         gold_unreachable();
5258     }
5259 }
5260
5261 // Decide whether the symbol needs an entry in the global part of the primary
5262 // GOT, setting global_got_area accordingly.  Count the number of global
5263 // symbols that are in the primary GOT only because they have dynamic
5264 // relocations R_MIPS_REL32 against them (reloc_only_gotno).
5265
5266 template<int size, bool big_endian>
5267 void
5268 Mips_got_info<size, big_endian>::count_got_symbols(Symbol_table* symtab)
5269 {
5270   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5271        p = this->global_got_symbols_.begin();
5272        p != this->global_got_symbols_.end();
5273        ++p)
5274     {
5275       Mips_symbol<size>* sym = *p;
5276       // Make a final decision about whether the symbol belongs in the
5277       // local or global GOT.  Symbols that bind locally can (and in the
5278       // case of forced-local symbols, must) live in the local GOT.
5279       // Those that are aren't in the dynamic symbol table must also
5280       // live in the local GOT.
5281
5282       if (!sym->should_add_dynsym_entry(symtab)
5283           || (sym->got_only_for_calls()
5284               ? symbol_calls_local(sym, sym->should_add_dynsym_entry(symtab))
5285               : symbol_references_local(sym,
5286                                         sym->should_add_dynsym_entry(symtab))))
5287         // The symbol belongs in the local GOT.  We no longer need this
5288         // entry if it was only used for relocations; those relocations
5289         // will be against the null or section symbol instead.
5290         sym->set_global_got_area(GGA_NONE);
5291       else if (sym->global_got_area() == GGA_RELOC_ONLY)
5292         {
5293           ++this->reloc_only_gotno_;
5294           ++this->global_gotno_ ;
5295         }
5296     }
5297 }
5298
5299 // Return the offset of GOT page entry for VALUE.  Initialize the entry with
5300 // VALUE if it is not initialized.
5301
5302 template<int size, bool big_endian>
5303 unsigned int
5304 Mips_got_info<size, big_endian>::get_got_page_offset(Mips_address value,
5305     Mips_output_data_got<size, big_endian>* got)
5306 {
5307   typename Got_page_offsets::iterator it = this->got_page_offsets_.find(value);
5308   if (it != this->got_page_offsets_.end())
5309     return it->second;
5310
5311   gold_assert(this->got_page_offset_next_ < this->got_page_offset_start_
5312               + (size/8) * this->page_gotno_);
5313
5314   unsigned int got_offset = this->got_page_offset_next_;
5315   this->got_page_offsets_[value] = got_offset;
5316   this->got_page_offset_next_ += size/8;
5317   got->update_got_entry(got_offset, value);
5318   return got_offset;
5319 }
5320
5321 // Remove lazy-binding stubs for global symbols in this GOT.
5322
5323 template<int size, bool big_endian>
5324 void
5325 Mips_got_info<size, big_endian>::remove_lazy_stubs(
5326     Target_mips<size, big_endian>* target)
5327 {
5328   for (typename Got_entry_set::iterator
5329        p = this->got_entries_.begin();
5330        p != this->got_entries_.end();
5331        ++p)
5332     {
5333       Mips_got_entry<size, big_endian>* entry = *p;
5334       if (entry->is_for_global_symbol())
5335         target->remove_lazy_stub_entry(entry->sym());
5336     }
5337 }
5338
5339 // Count the number of GOT entries required.
5340
5341 template<int size, bool big_endian>
5342 void
5343 Mips_got_info<size, big_endian>::count_got_entries()
5344 {
5345   for (typename Got_entry_set::iterator
5346        p = this->got_entries_.begin();
5347        p != this->got_entries_.end();
5348        ++p)
5349     {
5350       this->count_got_entry(*p);
5351     }
5352 }
5353
5354 // Count the number of GOT entries required by ENTRY.  Accumulate the result.
5355
5356 template<int size, bool big_endian>
5357 void
5358 Mips_got_info<size, big_endian>::count_got_entry(
5359     Mips_got_entry<size, big_endian>* entry)
5360 {
5361   if (entry->is_tls_entry())
5362     this->tls_gotno_ += mips_tls_got_entries(entry->tls_type());
5363   else if (entry->is_for_local_symbol()
5364            || entry->sym()->global_got_area() == GGA_NONE)
5365     ++this->local_gotno_;
5366   else
5367     ++this->global_gotno_;
5368 }
5369
5370 // Add FROM's GOT entries.
5371
5372 template<int size, bool big_endian>
5373 void
5374 Mips_got_info<size, big_endian>::add_got_entries(
5375     Mips_got_info<size, big_endian>* from)
5376 {
5377   for (typename Got_entry_set::iterator
5378        p = from->got_entries_.begin();
5379        p != from->got_entries_.end();
5380        ++p)
5381     {
5382       Mips_got_entry<size, big_endian>* entry = *p;
5383       if (this->got_entries_.find(entry) == this->got_entries_.end())
5384         {
5385           Mips_got_entry<size, big_endian>* entry2 =
5386             new Mips_got_entry<size, big_endian>(*entry);
5387           this->got_entries_.insert(entry2);
5388           this->count_got_entry(entry);
5389         }
5390     }
5391 }
5392
5393 // Add FROM's GOT page entries.
5394
5395 template<int size, bool big_endian>
5396 void
5397 Mips_got_info<size, big_endian>::add_got_page_entries(
5398     Mips_got_info<size, big_endian>* from)
5399 {
5400   for (typename Got_page_entry_set::iterator
5401        p = from->got_page_entries_.begin();
5402        p != from->got_page_entries_.end();
5403        ++p)
5404     {
5405       Got_page_entry* entry = *p;
5406       if (this->got_page_entries_.find(entry) == this->got_page_entries_.end())
5407         {
5408           Got_page_entry* entry2 = new Got_page_entry(*entry);
5409           this->got_page_entries_.insert(entry2);
5410           this->page_gotno_ += entry->num_pages;
5411         }
5412     }
5413 }
5414
5415 // Mips_output_data_got methods.
5416
5417 // Lay out the GOT.  Add local, global and TLS entries.  If GOT is
5418 // larger than 64K, create multi-GOT.
5419
5420 template<int size, bool big_endian>
5421 void
5422 Mips_output_data_got<size, big_endian>::lay_out_got(Layout* layout,
5423     Symbol_table* symtab, const Input_objects* input_objects)
5424 {
5425   // Decide which symbols need to go in the global part of the GOT and
5426   // count the number of reloc-only GOT symbols.
5427   this->master_got_info_->count_got_symbols(symtab);
5428
5429   // Count the number of GOT entries.
5430   this->master_got_info_->count_got_entries();
5431
5432   unsigned int got_size = this->master_got_info_->got_size();
5433   if (got_size > Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE)
5434     this->lay_out_multi_got(layout, input_objects);
5435   else
5436     {
5437       // Record that all objects use single GOT.
5438       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
5439            p != input_objects->relobj_end();
5440            ++p)
5441         {
5442           Mips_relobj<size, big_endian>* object =
5443             Mips_relobj<size, big_endian>::as_mips_relobj(*p);
5444           if (object->get_got_info() != NULL)
5445             object->set_got_info(this->master_got_info_);
5446         }
5447
5448       this->master_got_info_->add_local_entries(this->target_, layout);
5449       this->master_got_info_->add_global_entries(this->target_, layout,
5450                                                  /*not used*/-1U);
5451       this->master_got_info_->add_tls_entries(this->target_, layout);
5452     }
5453 }
5454
5455 // Create multi-GOT.  For every GOT, add local, global and TLS entries.
5456
5457 template<int size, bool big_endian>
5458 void
5459 Mips_output_data_got<size, big_endian>::lay_out_multi_got(Layout* layout,
5460     const Input_objects* input_objects)
5461 {
5462   // Try to merge the GOTs of input objects together, as long as they
5463   // don't seem to exceed the maximum GOT size, choosing one of them
5464   // to be the primary GOT.
5465   this->merge_gots(input_objects);
5466
5467   // Every symbol that is referenced in a dynamic relocation must be
5468   // present in the primary GOT.
5469   this->primary_got_->set_global_gotno(this->master_got_info_->global_gotno());
5470
5471   // Add GOT entries.
5472   unsigned int i = 0;
5473   unsigned int offset = 0;
5474   Mips_got_info<size, big_endian>* g = this->primary_got_;
5475   do
5476     {
5477       g->set_index(i);
5478       g->set_offset(offset);
5479
5480       g->add_local_entries(this->target_, layout);
5481       if (i == 0)
5482         g->add_global_entries(this->target_, layout,
5483                               (this->master_got_info_->global_gotno()
5484                                - this->master_got_info_->reloc_only_gotno()));
5485       else
5486         g->add_global_entries(this->target_, layout, /*not used*/-1U);
5487       g->add_tls_entries(this->target_, layout);
5488
5489       // Forbid global symbols in every non-primary GOT from having
5490       // lazy-binding stubs.
5491       if (i > 0)
5492         g->remove_lazy_stubs(this->target_);
5493
5494       ++i;
5495       offset += g->got_size();
5496       g = g->next();
5497     }
5498   while (g);
5499 }
5500
5501 // Attempt to merge GOTs of different input objects.  Try to use as much as
5502 // possible of the primary GOT, since it doesn't require explicit dynamic
5503 // relocations, but don't use objects that would reference global symbols
5504 // out of the addressable range.  Failing the primary GOT, attempt to merge
5505 // with the current GOT, or finish the current GOT and then make make the new
5506 // GOT current.
5507
5508 template<int size, bool big_endian>
5509 void
5510 Mips_output_data_got<size, big_endian>::merge_gots(
5511     const Input_objects* input_objects)
5512 {
5513   gold_assert(this->primary_got_ == NULL);
5514   Mips_got_info<size, big_endian>* current = NULL;
5515
5516   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
5517        p != input_objects->relobj_end();
5518        ++p)
5519     {
5520       Mips_relobj<size, big_endian>* object =
5521         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
5522
5523       Mips_got_info<size, big_endian>* g = object->get_got_info();
5524       if (g == NULL)
5525         continue;
5526
5527       g->count_got_entries();
5528
5529       // Work out the number of page, local and TLS entries.
5530       unsigned int estimate = this->master_got_info_->page_gotno();
5531       if (estimate > g->page_gotno())
5532         estimate = g->page_gotno();
5533       estimate += g->local_gotno() + g->tls_gotno();
5534
5535       // We place TLS GOT entries after both locals and globals.  The globals
5536       // for the primary GOT may overflow the normal GOT size limit, so be
5537       // sure not to merge a GOT which requires TLS with the primary GOT in that
5538       // case.  This doesn't affect non-primary GOTs.
5539       estimate += (g->tls_gotno() > 0 ? this->master_got_info_->global_gotno()
5540                                       : g->global_gotno());
5541
5542       unsigned int max_count =
5543         Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2;
5544       if (estimate <= max_count)
5545         {
5546           // If we don't have a primary GOT, use it as
5547           // a starting point for the primary GOT.
5548           if (!this->primary_got_)
5549             {
5550               this->primary_got_ = g;
5551               continue;
5552             }
5553
5554           // Try merging with the primary GOT.
5555           if (this->merge_got_with(g, object, this->primary_got_))
5556             continue;
5557         }
5558
5559       // If we can merge with the last-created GOT, do it.
5560       if (current && this->merge_got_with(g, object, current))
5561         continue;
5562
5563       // Well, we couldn't merge, so create a new GOT.  Don't check if it
5564       // fits; if it turns out that it doesn't, we'll get relocation
5565       // overflows anyway.
5566       g->set_next(current);
5567       current = g;
5568     }
5569
5570   // If we do not find any suitable primary GOT, create an empty one.
5571   if (this->primary_got_ == NULL)
5572     this->primary_got_ = new Mips_got_info<size, big_endian>();
5573
5574   // Link primary GOT with secondary GOTs.
5575   this->primary_got_->set_next(current);
5576 }
5577
5578 // Consider merging FROM, which is OBJECT's GOT, into TO.  Return false if
5579 // this would lead to overflow, true if they were merged successfully.
5580
5581 template<int size, bool big_endian>
5582 bool
5583 Mips_output_data_got<size, big_endian>::merge_got_with(
5584     Mips_got_info<size, big_endian>* from,
5585     Mips_relobj<size, big_endian>* object,
5586     Mips_got_info<size, big_endian>* to)
5587 {
5588   // Work out how many page entries we would need for the combined GOT.
5589   unsigned int estimate = this->master_got_info_->page_gotno();
5590   if (estimate >= from->page_gotno() + to->page_gotno())
5591     estimate = from->page_gotno() + to->page_gotno();
5592
5593   // Conservatively estimate how many local and TLS entries would be needed.
5594   estimate += from->local_gotno() + to->local_gotno();
5595   estimate += from->tls_gotno() + to->tls_gotno();
5596
5597   // If we're merging with the primary got, any TLS relocations will
5598   // come after the full set of global entries.  Otherwise estimate those
5599   // conservatively as well.
5600   if (to == this->primary_got_ && (from->tls_gotno() + to->tls_gotno()) > 0)
5601     estimate += this->master_got_info_->global_gotno();
5602   else
5603     estimate += from->global_gotno() + to->global_gotno();
5604
5605   // Bail out if the combined GOT might be too big.
5606   unsigned int max_count =
5607     Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2;
5608   if (estimate > max_count)
5609     return false;
5610
5611   // Transfer the object's GOT information from FROM to TO.
5612   to->add_got_entries(from);
5613   to->add_got_page_entries(from);
5614
5615   // Record that OBJECT should use output GOT TO.
5616   object->set_got_info(to);
5617
5618   return true;
5619 }
5620
5621 // Write out the GOT.
5622
5623 template<int size, bool big_endian>
5624 void
5625 Mips_output_data_got<size, big_endian>::do_write(Output_file* of)
5626 {
5627   // Call parent to write out GOT.
5628   Output_data_got<size, big_endian>::do_write(of);
5629
5630   const off_t offset = this->offset();
5631   const section_size_type oview_size =
5632     convert_to_section_size_type(this->data_size());
5633   unsigned char* const oview = of->get_output_view(offset, oview_size);
5634
5635   // Needed for fixing values of .got section.
5636   this->got_view_ = oview;
5637
5638   // Write lazy stub addresses.
5639   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5640        p = this->master_got_info_->global_got_symbols().begin();
5641        p != this->master_got_info_->global_got_symbols().end();
5642        ++p)
5643     {
5644       Mips_symbol<size>* mips_sym = *p;
5645       if (mips_sym->has_lazy_stub())
5646         {
5647           Valtype* wv = reinterpret_cast<Valtype*>(
5648             oview + this->get_primary_got_offset(mips_sym));
5649           Valtype value =
5650             this->target_->mips_stubs_section()->stub_address(mips_sym);
5651           elfcpp::Swap<size, big_endian>::writeval(wv, value);
5652         }
5653     }
5654
5655   // Add +1 to GGA_NONE nonzero MIPS16 and microMIPS entries.
5656   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5657        p = this->master_got_info_->global_got_symbols().begin();
5658        p != this->master_got_info_->global_got_symbols().end();
5659        ++p)
5660     {
5661       Mips_symbol<size>* mips_sym = *p;
5662       if (!this->multi_got()
5663           && (mips_sym->is_mips16() || mips_sym->is_micromips())
5664           && mips_sym->global_got_area() == GGA_NONE
5665           && mips_sym->has_got_offset(GOT_TYPE_STANDARD))
5666         {
5667           Valtype* wv = reinterpret_cast<Valtype*>(
5668             oview + mips_sym->got_offset(GOT_TYPE_STANDARD));
5669           Valtype value = elfcpp::Swap<size, big_endian>::readval(wv);
5670           if (value != 0)
5671             {
5672               value |= 1;
5673               elfcpp::Swap<size, big_endian>::writeval(wv, value);
5674             }
5675         }
5676     }
5677
5678   if (!this->secondary_got_relocs_.empty())
5679     {
5680       // Fixup for the secondary GOT R_MIPS_REL32 relocs.  For global
5681       // secondary GOT entries with non-zero initial value copy the value
5682       // to the corresponding primary GOT entry, and set the secondary GOT
5683       // entry to zero.
5684       // TODO(sasa): This is workaround.  It needs to be investigated further.
5685
5686       for (size_t i = 0; i < this->secondary_got_relocs_.size(); ++i)
5687         {
5688           Static_reloc& reloc(this->secondary_got_relocs_[i]);
5689           if (reloc.symbol_is_global())
5690             {
5691               Mips_symbol<size>* gsym = reloc.symbol();
5692               gold_assert(gsym != NULL);
5693
5694               unsigned got_offset = reloc.got_offset();
5695               gold_assert(got_offset < oview_size);
5696
5697               // Find primary GOT entry.
5698               Valtype* wv_prim = reinterpret_cast<Valtype*>(
5699                 oview + this->get_primary_got_offset(gsym));
5700
5701               // Find secondary GOT entry.
5702               Valtype* wv_sec = reinterpret_cast<Valtype*>(oview + got_offset);
5703
5704               Valtype value = elfcpp::Swap<size, big_endian>::readval(wv_sec);
5705               if (value != 0)
5706                 {
5707                   elfcpp::Swap<size, big_endian>::writeval(wv_prim, value);
5708                   elfcpp::Swap<size, big_endian>::writeval(wv_sec, 0);
5709                   gsym->set_applied_secondary_got_fixup();
5710                 }
5711             }
5712         }
5713
5714       of->write_output_view(offset, oview_size, oview);
5715     }
5716
5717   // We are done if there is no fix up.
5718   if (this->static_relocs_.empty())
5719     return;
5720
5721   Output_segment* tls_segment = this->layout_->tls_segment();
5722   gold_assert(tls_segment != NULL);
5723
5724   for (size_t i = 0; i < this->static_relocs_.size(); ++i)
5725     {
5726       Static_reloc& reloc(this->static_relocs_[i]);
5727
5728       Mips_address value;
5729       if (!reloc.symbol_is_global())
5730         {
5731           Sized_relobj_file<size, big_endian>* object = reloc.relobj();
5732           const Symbol_value<size>* psymval =
5733             object->local_symbol(reloc.index());
5734
5735           // We are doing static linking.  Issue an error and skip this
5736           // relocation if the symbol is undefined or in a discarded_section.
5737           bool is_ordinary;
5738           unsigned int shndx = psymval->input_shndx(&is_ordinary);
5739           if ((shndx == elfcpp::SHN_UNDEF)
5740               || (is_ordinary
5741                   && shndx != elfcpp::SHN_UNDEF
5742                   && !object->is_section_included(shndx)
5743                   && !this->symbol_table_->is_section_folded(object, shndx)))
5744             {
5745               gold_error(_("undefined or discarded local symbol %u from "
5746                            " object %s in GOT"),
5747                          reloc.index(), reloc.relobj()->name().c_str());
5748               continue;
5749             }
5750
5751           value = psymval->value(object, 0);
5752         }
5753       else
5754         {
5755           const Mips_symbol<size>* gsym = reloc.symbol();
5756           gold_assert(gsym != NULL);
5757
5758           // We are doing static linking.  Issue an error and skip this
5759           // relocation if the symbol is undefined or in a discarded_section
5760           // unless it is a weakly_undefined symbol.
5761           if ((gsym->is_defined_in_discarded_section() || gsym->is_undefined())
5762               && !gsym->is_weak_undefined())
5763             {
5764               gold_error(_("undefined or discarded symbol %s in GOT"),
5765                          gsym->name());
5766               continue;
5767             }
5768
5769           if (!gsym->is_weak_undefined())
5770             value = gsym->value();
5771           else
5772             value = 0;
5773         }
5774
5775       unsigned got_offset = reloc.got_offset();
5776       gold_assert(got_offset < oview_size);
5777
5778       Valtype* wv = reinterpret_cast<Valtype*>(oview + got_offset);
5779       Valtype x;
5780
5781       switch (reloc.r_type())
5782         {
5783         case elfcpp::R_MIPS_TLS_DTPMOD32:
5784         case elfcpp::R_MIPS_TLS_DTPMOD64:
5785           x = value;
5786           break;
5787         case elfcpp::R_MIPS_TLS_DTPREL32:
5788         case elfcpp::R_MIPS_TLS_DTPREL64:
5789           x = value - elfcpp::DTP_OFFSET;
5790           break;
5791         case elfcpp::R_MIPS_TLS_TPREL32:
5792         case elfcpp::R_MIPS_TLS_TPREL64:
5793           x = value - elfcpp::TP_OFFSET;
5794           break;
5795         default:
5796           gold_unreachable();
5797           break;
5798         }
5799
5800       elfcpp::Swap<size, big_endian>::writeval(wv, x);
5801     }
5802
5803   of->write_output_view(offset, oview_size, oview);
5804 }
5805
5806 // Mips_relobj methods.
5807
5808 // Count the local symbols.  The Mips backend needs to know if a symbol
5809 // is a MIPS16 or microMIPS function or not.  For global symbols, it is easy
5810 // because the Symbol object keeps the ELF symbol type and st_other field.
5811 // For local symbol it is harder because we cannot access this information.
5812 // So we override the do_count_local_symbol in parent and scan local symbols to
5813 // mark MIPS16 and microMIPS functions.  This is not the most efficient way but
5814 // I do not want to slow down other ports by calling a per symbol target hook
5815 // inside Sized_relobj_file<size, big_endian>::do_count_local_symbols.
5816
5817 template<int size, bool big_endian>
5818 void
5819 Mips_relobj<size, big_endian>::do_count_local_symbols(
5820     Stringpool_template<char>* pool,
5821     Stringpool_template<char>* dynpool)
5822 {
5823   // Ask parent to count the local symbols.
5824   Sized_relobj_file<size, big_endian>::do_count_local_symbols(pool, dynpool);
5825   const unsigned int loccount = this->local_symbol_count();
5826   if (loccount == 0)
5827     return;
5828
5829   // Initialize the mips16 and micromips function bit-vector.
5830   this->local_symbol_is_mips16_.resize(loccount, false);
5831   this->local_symbol_is_micromips_.resize(loccount, false);
5832
5833   // Read the symbol table section header.
5834   const unsigned int symtab_shndx = this->symtab_shndx();
5835   elfcpp::Shdr<size, big_endian>
5836     symtabshdr(this, this->elf_file()->section_header(symtab_shndx));
5837   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
5838
5839   // Read the local symbols.
5840   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
5841   gold_assert(loccount == symtabshdr.get_sh_info());
5842   off_t locsize = loccount * sym_size;
5843   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
5844                                               locsize, true, true);
5845
5846   // Loop over the local symbols and mark any MIPS16 or microMIPS local symbols.
5847
5848   // Skip the first dummy symbol.
5849   psyms += sym_size;
5850   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
5851     {
5852       elfcpp::Sym<size, big_endian> sym(psyms);
5853       unsigned char st_other = sym.get_st_other();
5854       this->local_symbol_is_mips16_[i] = elfcpp::elf_st_is_mips16(st_other);
5855       this->local_symbol_is_micromips_[i] =
5856         elfcpp::elf_st_is_micromips(st_other);
5857     }
5858 }
5859
5860 // Read the symbol information.
5861
5862 template<int size, bool big_endian>
5863 void
5864 Mips_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
5865 {
5866   // Call parent class to read symbol information.
5867   this->base_read_symbols(sd);
5868
5869   // Read processor-specific flags in ELF file header.
5870   const unsigned char* pehdr = this->get_view(elfcpp::file_header_offset,
5871                                             elfcpp::Elf_sizes<size>::ehdr_size,
5872                                             true, false);
5873   elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
5874   this->processor_specific_flags_ = ehdr.get_e_flags();
5875
5876   // Get the section names.
5877   const unsigned char* pnamesu = sd->section_names->data();
5878   const char* pnames = reinterpret_cast<const char*>(pnamesu);
5879
5880   // Initialize the mips16 stub section bit-vectors.
5881   this->section_is_mips16_fn_stub_.resize(this->shnum(), false);
5882   this->section_is_mips16_call_stub_.resize(this->shnum(), false);
5883   this->section_is_mips16_call_fp_stub_.resize(this->shnum(), false);
5884
5885   const size_t shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
5886   const unsigned char* pshdrs = sd->section_headers->data();
5887   const unsigned char* ps = pshdrs + shdr_size;
5888   for (unsigned int i = 1; i < this->shnum(); ++i, ps += shdr_size)
5889     {
5890       elfcpp::Shdr<size, big_endian> shdr(ps);
5891
5892       if (shdr.get_sh_type() == elfcpp::SHT_MIPS_REGINFO)
5893         {
5894           // Read the gp value that was used to create this object.  We need the
5895           // gp value while processing relocs.  The .reginfo section is not used
5896           // in the 64-bit MIPS ELF ABI.
5897           section_offset_type section_offset = shdr.get_sh_offset();
5898           section_size_type section_size =
5899             convert_to_section_size_type(shdr.get_sh_size());
5900           const unsigned char* view =
5901              this->get_view(section_offset, section_size, true, false);
5902
5903           this->gp_ = elfcpp::Swap<size, big_endian>::readval(view + 20);
5904
5905           // Read the rest of .reginfo.
5906           this->gprmask_ = elfcpp::Swap<size, big_endian>::readval(view);
5907           this->cprmask1_ = elfcpp::Swap<size, big_endian>::readval(view + 4);
5908           this->cprmask2_ = elfcpp::Swap<size, big_endian>::readval(view + 8);
5909           this->cprmask3_ = elfcpp::Swap<size, big_endian>::readval(view + 12);
5910           this->cprmask4_ = elfcpp::Swap<size, big_endian>::readval(view + 16);
5911         }
5912
5913       const char* name = pnames + shdr.get_sh_name();
5914       this->section_is_mips16_fn_stub_[i] = is_prefix_of(".mips16.fn", name);
5915       this->section_is_mips16_call_stub_[i] =
5916         is_prefix_of(".mips16.call.", name);
5917       this->section_is_mips16_call_fp_stub_[i] =
5918         is_prefix_of(".mips16.call.fp.", name);
5919
5920       if (strcmp(name, ".pdr") == 0)
5921         {
5922           gold_assert(this->pdr_shndx_ == -1U);
5923           this->pdr_shndx_ = i;
5924         }
5925     }
5926 }
5927
5928 // Discard MIPS16 stub secions that are not needed.
5929
5930 template<int size, bool big_endian>
5931 void
5932 Mips_relobj<size, big_endian>::discard_mips16_stub_sections(Symbol_table* symtab)
5933 {
5934   for (typename Mips16_stubs_int_map::const_iterator
5935        it = this->mips16_stub_sections_.begin();
5936        it != this->mips16_stub_sections_.end(); ++it)
5937     {
5938       Mips16_stub_section<size, big_endian>* stub_section = it->second;
5939       if (!stub_section->is_target_found())
5940         {
5941           gold_error(_("no relocation found in mips16 stub section '%s'"),
5942                      stub_section->object()
5943                        ->section_name(stub_section->shndx()).c_str());
5944         }
5945
5946       bool discard = false;
5947       if (stub_section->is_for_local_function())
5948         {
5949           if (stub_section->is_fn_stub())
5950             {
5951               // This stub is for a local symbol.  This stub will only
5952               // be needed if there is some relocation in this object,
5953               // other than a 16 bit function call, which refers to this
5954               // symbol.
5955               if (!this->has_local_non_16bit_call_relocs(stub_section->r_sym()))
5956                 discard = true;
5957               else
5958                 this->add_local_mips16_fn_stub(stub_section);
5959             }
5960           else
5961             {
5962               // This stub is for a local symbol.  This stub will only
5963               // be needed if there is some relocation (R_MIPS16_26) in
5964               // this object that refers to this symbol.
5965               gold_assert(stub_section->is_call_stub()
5966                           || stub_section->is_call_fp_stub());
5967               if (!this->has_local_16bit_call_relocs(stub_section->r_sym()))
5968                 discard = true;
5969               else
5970                 this->add_local_mips16_call_stub(stub_section);
5971             }
5972         }
5973       else
5974         {
5975           Mips_symbol<size>* gsym = stub_section->gsym();
5976           if (stub_section->is_fn_stub())
5977             {
5978               if (gsym->has_mips16_fn_stub())
5979                 // We already have a stub for this function.
5980                 discard = true;
5981               else
5982                 {
5983                   gsym->set_mips16_fn_stub(stub_section);
5984                   if (gsym->should_add_dynsym_entry(symtab))
5985                     {
5986                       // If we have a MIPS16 function with a stub, the
5987                       // dynamic symbol must refer to the stub, since only
5988                       // the stub uses the standard calling conventions.
5989                       gsym->set_need_fn_stub();
5990                       if (gsym->is_from_dynobj())
5991                         gsym->set_needs_dynsym_value();
5992                     }
5993                 }
5994               if (!gsym->need_fn_stub())
5995                 discard = true;
5996             }
5997           else if (stub_section->is_call_stub())
5998             {
5999               if (gsym->is_mips16())
6000                 // We don't need the call_stub; this is a 16 bit
6001                 // function, so calls from other 16 bit functions are
6002                 // OK.
6003                 discard = true;
6004               else if (gsym->has_mips16_call_stub())
6005                 // We already have a stub for this function.
6006                 discard = true;
6007               else
6008                 gsym->set_mips16_call_stub(stub_section);
6009             }
6010           else
6011             {
6012               gold_assert(stub_section->is_call_fp_stub());
6013               if (gsym->is_mips16())
6014                 // We don't need the call_stub; this is a 16 bit
6015                 // function, so calls from other 16 bit functions are
6016                 // OK.
6017                 discard = true;
6018               else if (gsym->has_mips16_call_fp_stub())
6019                 // We already have a stub for this function.
6020                 discard = true;
6021               else
6022                 gsym->set_mips16_call_fp_stub(stub_section);
6023             }
6024         }
6025       if (discard)
6026         this->set_output_section(stub_section->shndx(), NULL);
6027    }
6028 }
6029
6030 // Mips_output_data_la25_stub methods.
6031
6032 // Template for standard LA25 stub.
6033 template<int size, bool big_endian>
6034 const uint32_t
6035 Mips_output_data_la25_stub<size, big_endian>::la25_stub_entry[] =
6036 {
6037   0x3c190000,           // lui $25,%hi(func)
6038   0x08000000,           // j func
6039   0x27390000,           // add $25,$25,%lo(func)
6040   0x00000000            // nop
6041 };
6042
6043 // Template for microMIPS LA25 stub.
6044 template<int size, bool big_endian>
6045 const uint32_t
6046 Mips_output_data_la25_stub<size, big_endian>::la25_stub_micromips_entry[] =
6047 {
6048   0x41b9, 0x0000,       // lui t9,%hi(func)
6049   0xd400, 0x0000,       // j func
6050   0x3339, 0x0000,       // addiu t9,t9,%lo(func)
6051   0x0000, 0x0000        // nop
6052 };
6053
6054 // Create la25 stub for a symbol.
6055
6056 template<int size, bool big_endian>
6057 void
6058 Mips_output_data_la25_stub<size, big_endian>::create_la25_stub(
6059     Symbol_table* symtab, Target_mips<size, big_endian>* target,
6060     Mips_symbol<size>* gsym)
6061 {
6062   if (!gsym->has_la25_stub())
6063     {
6064       gsym->set_la25_stub_offset(this->symbols_.size() * 16);
6065       this->symbols_.insert(gsym);
6066       this->create_stub_symbol(gsym, symtab, target, 16);
6067     }
6068 }
6069
6070 // Create a symbol for SYM stub's value and size, to help make the disassembly
6071 // easier to read.
6072
6073 template<int size, bool big_endian>
6074 void
6075 Mips_output_data_la25_stub<size, big_endian>::create_stub_symbol(
6076     Mips_symbol<size>* sym, Symbol_table* symtab,
6077     Target_mips<size, big_endian>* target, uint64_t symsize)
6078 {
6079   std::string name(".pic.");
6080   name += sym->name();
6081
6082   unsigned int offset = sym->la25_stub_offset();
6083   if (sym->is_micromips())
6084     offset |= 1;
6085
6086   // Make it a local function.
6087   Symbol* new_sym = symtab->define_in_output_data(name.c_str(), NULL,
6088                                       Symbol_table::PREDEFINED,
6089                                       target->la25_stub_section(),
6090                                       offset, symsize, elfcpp::STT_FUNC,
6091                                       elfcpp::STB_LOCAL,
6092                                       elfcpp::STV_DEFAULT, 0,
6093                                       false, false);
6094   new_sym->set_is_forced_local();
6095 }
6096
6097 // Write out la25 stubs.  This uses the hand-coded instructions above,
6098 // and adjusts them as needed.
6099
6100 template<int size, bool big_endian>
6101 void
6102 Mips_output_data_la25_stub<size, big_endian>::do_write(Output_file* of)
6103 {
6104   const off_t offset = this->offset();
6105   const section_size_type oview_size =
6106     convert_to_section_size_type(this->data_size());
6107   unsigned char* const oview = of->get_output_view(offset, oview_size);
6108
6109   for (typename Unordered_set<Mips_symbol<size>*>::iterator
6110        p = this->symbols_.begin();
6111        p != this->symbols_.end();
6112        ++p)
6113     {
6114       Mips_symbol<size>* sym = *p;
6115       unsigned char* pov = oview + sym->la25_stub_offset();
6116
6117       Mips_address target = sym->value();
6118       if (!sym->is_micromips())
6119         {
6120           elfcpp::Swap<32, big_endian>::writeval(pov,
6121               la25_stub_entry[0] | (((target + 0x8000) >> 16) & 0xffff));
6122           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6123               la25_stub_entry[1] | ((target >> 2) & 0x3ffffff));
6124           elfcpp::Swap<32, big_endian>::writeval(pov + 8,
6125               la25_stub_entry[2] | (target & 0xffff));
6126           elfcpp::Swap<32, big_endian>::writeval(pov + 12, la25_stub_entry[3]);
6127         }
6128       else
6129         {
6130           target |= 1;
6131           // First stub instruction.  Paste high 16-bits of the target.
6132           elfcpp::Swap<16, big_endian>::writeval(pov,
6133                                                  la25_stub_micromips_entry[0]);
6134           elfcpp::Swap<16, big_endian>::writeval(pov + 2,
6135               ((target + 0x8000) >> 16) & 0xffff);
6136           // Second stub instruction.  Paste low 26-bits of the target, shifted
6137           // right by 1.
6138           elfcpp::Swap<16, big_endian>::writeval(pov + 4,
6139               la25_stub_micromips_entry[2] | ((target >> 17) & 0x3ff));
6140           elfcpp::Swap<16, big_endian>::writeval(pov + 6,
6141               la25_stub_micromips_entry[3] | ((target >> 1) & 0xffff));
6142           // Third stub instruction.  Paste low 16-bits of the target.
6143           elfcpp::Swap<16, big_endian>::writeval(pov + 8,
6144                                                  la25_stub_micromips_entry[4]);
6145           elfcpp::Swap<16, big_endian>::writeval(pov + 10, target & 0xffff);
6146           // Fourth stub instruction.
6147           elfcpp::Swap<16, big_endian>::writeval(pov + 12,
6148                                                  la25_stub_micromips_entry[6]);
6149           elfcpp::Swap<16, big_endian>::writeval(pov + 14,
6150                                                  la25_stub_micromips_entry[7]);
6151         }
6152     }
6153
6154   of->write_output_view(offset, oview_size, oview);
6155 }
6156
6157 // Mips_output_data_plt methods.
6158
6159 // The format of the first PLT entry in an O32 executable.
6160 template<int size, bool big_endian>
6161 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_o32[] =
6162 {
6163   0x3c1c0000,         // lui $28, %hi(&GOTPLT[0])
6164   0x8f990000,         // lw $25, %lo(&GOTPLT[0])($28)
6165   0x279c0000,         // addiu $28, $28, %lo(&GOTPLT[0])
6166   0x031cc023,         // subu $24, $24, $28
6167   0x03e07825,         // or $15, $31, zero
6168   0x0018c082,         // srl $24, $24, 2
6169   0x0320f809,         // jalr $25
6170   0x2718fffe          // subu $24, $24, 2
6171 };
6172
6173 // The format of the first PLT entry in an N32 executable.  Different
6174 // because gp ($28) is not available; we use t2 ($14) instead.
6175 template<int size, bool big_endian>
6176 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n32[] =
6177 {
6178   0x3c0e0000,         // lui $14, %hi(&GOTPLT[0])
6179   0x8dd90000,         // lw $25, %lo(&GOTPLT[0])($14)
6180   0x25ce0000,         // addiu $14, $14, %lo(&GOTPLT[0])
6181   0x030ec023,         // subu $24, $24, $14
6182   0x03e07825,         // or $15, $31, zero
6183   0x0018c082,         // srl $24, $24, 2
6184   0x0320f809,         // jalr $25
6185   0x2718fffe          // subu $24, $24, 2
6186 };
6187
6188 // The format of the first PLT entry in an N64 executable.  Different
6189 // from N32 because of the increased size of GOT entries.
6190 template<int size, bool big_endian>
6191 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n64[] =
6192 {
6193   0x3c0e0000,         // lui $14, %hi(&GOTPLT[0])
6194   0xddd90000,         // ld $25, %lo(&GOTPLT[0])($14)
6195   0x25ce0000,         // addiu $14, $14, %lo(&GOTPLT[0])
6196   0x030ec023,         // subu $24, $24, $14
6197   0x03e07825,         // or $15, $31, zero
6198   0x0018c0c2,         // srl $24, $24, 3
6199   0x0320f809,         // jalr $25
6200   0x2718fffe          // subu $24, $24, 2
6201 };
6202
6203 // The format of the microMIPS first PLT entry in an O32 executable.
6204 // We rely on v0 ($2) rather than t8 ($24) to contain the address
6205 // of the GOTPLT entry handled, so this stub may only be used when
6206 // all the subsequent PLT entries are microMIPS code too.
6207 //
6208 // The trailing NOP is for alignment and correct disassembly only.
6209 template<int size, bool big_endian>
6210 const uint32_t Mips_output_data_plt<size, big_endian>::
6211 plt0_entry_micromips_o32[] =
6212 {
6213   0x7980, 0x0000,      // addiupc $3, (&GOTPLT[0]) - .
6214   0xff23, 0x0000,      // lw $25, 0($3)
6215   0x0535,              // subu $2, $2, $3
6216   0x2525,              // srl $2, $2, 2
6217   0x3302, 0xfffe,      // subu $24, $2, 2
6218   0x0dff,              // move $15, $31
6219   0x45f9,              // jalrs $25
6220   0x0f83,              // move $28, $3
6221   0x0c00               // nop
6222 };
6223
6224 // The format of the microMIPS first PLT entry in an O32 executable
6225 // in the insn32 mode.
6226 template<int size, bool big_endian>
6227 const uint32_t Mips_output_data_plt<size, big_endian>::
6228 plt0_entry_micromips32_o32[] =
6229 {
6230   0x41bc, 0x0000,      // lui $28, %hi(&GOTPLT[0])
6231   0xff3c, 0x0000,      // lw $25, %lo(&GOTPLT[0])($28)
6232   0x339c, 0x0000,      // addiu $28, $28, %lo(&GOTPLT[0])
6233   0x0398, 0xc1d0,      // subu $24, $24, $28
6234   0x001f, 0x7a90,      // or $15, $31, zero
6235   0x0318, 0x1040,      // srl $24, $24, 2
6236   0x03f9, 0x0f3c,      // jalr $25
6237   0x3318, 0xfffe       // subu $24, $24, 2
6238 };
6239
6240 // The format of subsequent standard entries in the PLT.
6241 template<int size, bool big_endian>
6242 const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry[] =
6243 {
6244   0x3c0f0000,           // lui $15, %hi(.got.plt entry)
6245   0x8df90000,           // l[wd] $25, %lo(.got.plt entry)($15)
6246   0x03200008,           // jr $25
6247   0x25f80000            // addiu $24, $15, %lo(.got.plt entry)
6248 };
6249
6250 // The format of subsequent MIPS16 o32 PLT entries.  We use v1 ($3) as a
6251 // temporary because t8 ($24) and t9 ($25) are not directly addressable.
6252 // Note that this differs from the GNU ld which uses both v0 ($2) and v1 ($3).
6253 // We cannot use v0 because MIPS16 call stubs from the CS toolchain expect
6254 // target function address in register v0.
6255 template<int size, bool big_endian>
6256 const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry_mips16_o32[] =
6257 {
6258   0xb303,              // lw $3, 12($pc)
6259   0x651b,              // move $24, $3
6260   0x9b60,              // lw $3, 0($3)
6261   0xeb00,              // jr $3
6262   0x653b,              // move $25, $3
6263   0x6500,              // nop
6264   0x0000, 0x0000       // .word (.got.plt entry)
6265 };
6266
6267 // The format of subsequent microMIPS o32 PLT entries.  We use v0 ($2)
6268 // as a temporary because t8 ($24) is not addressable with ADDIUPC.
6269 template<int size, bool big_endian>
6270 const uint32_t Mips_output_data_plt<size, big_endian>::
6271 plt_entry_micromips_o32[] =
6272 {
6273   0x7900, 0x0000,      // addiupc $2, (.got.plt entry) - .
6274   0xff22, 0x0000,      // lw $25, 0($2)
6275   0x4599,              // jr $25
6276   0x0f02               // move $24, $2
6277 };
6278
6279 // The format of subsequent microMIPS o32 PLT entries in the insn32 mode.
6280 template<int size, bool big_endian>
6281 const uint32_t Mips_output_data_plt<size, big_endian>::
6282 plt_entry_micromips32_o32[] =
6283 {
6284   0x41af, 0x0000,      // lui $15, %hi(.got.plt entry)
6285   0xff2f, 0x0000,      // lw $25, %lo(.got.plt entry)($15)
6286   0x0019, 0x0f3c,      // jr $25
6287   0x330f, 0x0000       // addiu $24, $15, %lo(.got.plt entry)
6288 };
6289
6290 // Add an entry to the PLT for a symbol referenced by r_type relocation.
6291
6292 template<int size, bool big_endian>
6293 void
6294 Mips_output_data_plt<size, big_endian>::add_entry(Mips_symbol<size>* gsym,
6295                                                   unsigned int r_type)
6296 {
6297   gold_assert(!gsym->has_plt_offset());
6298
6299   // Final PLT offset for a symbol will be set in method set_plt_offsets().
6300   gsym->set_plt_offset(this->entry_count() * sizeof(plt_entry)
6301                        + sizeof(plt0_entry_o32));
6302   this->symbols_.push_back(gsym);
6303
6304   // Record whether the relocation requires a standard MIPS
6305   // or a compressed code entry.
6306   if (jal_reloc(r_type))
6307    {
6308      if (r_type == elfcpp::R_MIPS_26)
6309        gsym->set_needs_mips_plt(true);
6310      else
6311        gsym->set_needs_comp_plt(true);
6312    }
6313
6314   section_offset_type got_offset = this->got_plt_->current_data_size();
6315
6316   // Every PLT entry needs a GOT entry which points back to the PLT
6317   // entry (this will be changed by the dynamic linker, normally
6318   // lazily when the function is called).
6319   this->got_plt_->set_current_data_size(got_offset + size/8);
6320
6321   gsym->set_needs_dynsym_entry();
6322   this->rel_->add_global(gsym, elfcpp::R_MIPS_JUMP_SLOT, this->got_plt_,
6323                          got_offset);
6324 }
6325
6326 // Set final PLT offsets.  For each symbol, determine whether standard or
6327 // compressed (MIPS16 or microMIPS) PLT entry is used.
6328
6329 template<int size, bool big_endian>
6330 void
6331 Mips_output_data_plt<size, big_endian>::set_plt_offsets()
6332 {
6333   // The sizes of individual PLT entries.
6334   unsigned int plt_mips_entry_size = this->standard_plt_entry_size();
6335   unsigned int plt_comp_entry_size = (!this->target_->is_output_newabi()
6336                                       ? this->compressed_plt_entry_size() : 0);
6337
6338   for (typename std::vector<Mips_symbol<size>*>::const_iterator
6339        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6340     {
6341       Mips_symbol<size>* mips_sym = *p;
6342
6343       // There are no defined MIPS16 or microMIPS PLT entries for n32 or n64,
6344       // so always use a standard entry there.
6345       //
6346       // If the symbol has a MIPS16 call stub and gets a PLT entry, then
6347       // all MIPS16 calls will go via that stub, and there is no benefit
6348       // to having a MIPS16 entry.  And in the case of call_stub a
6349       // standard entry actually has to be used as the stub ends with a J
6350       // instruction.
6351       if (this->target_->is_output_newabi()
6352           || mips_sym->has_mips16_call_stub()
6353           || mips_sym->has_mips16_call_fp_stub())
6354         {
6355           mips_sym->set_needs_mips_plt(true);
6356           mips_sym->set_needs_comp_plt(false);
6357         }
6358
6359       // Otherwise, if there are no direct calls to the function, we
6360       // have a free choice of whether to use standard or compressed
6361       // entries.  Prefer microMIPS entries if the object is known to
6362       // contain microMIPS code, so that it becomes possible to create
6363       // pure microMIPS binaries.  Prefer standard entries otherwise,
6364       // because MIPS16 ones are no smaller and are usually slower.
6365       if (!mips_sym->needs_mips_plt() && !mips_sym->needs_comp_plt())
6366         {
6367           if (this->target_->is_output_micromips())
6368             mips_sym->set_needs_comp_plt(true);
6369           else
6370             mips_sym->set_needs_mips_plt(true);
6371         }
6372
6373       if (mips_sym->needs_mips_plt())
6374         {
6375           mips_sym->set_mips_plt_offset(this->plt_mips_offset_);
6376           this->plt_mips_offset_ += plt_mips_entry_size;
6377         }
6378       if (mips_sym->needs_comp_plt())
6379         {
6380           mips_sym->set_comp_plt_offset(this->plt_comp_offset_);
6381           this->plt_comp_offset_ += plt_comp_entry_size;
6382         }
6383     }
6384
6385     // Figure out the size of the PLT header if we know that we are using it.
6386     if (this->plt_mips_offset_ + this->plt_comp_offset_ != 0)
6387       this->plt_header_size_ = this->get_plt_header_size();
6388 }
6389
6390 // Write out the PLT.  This uses the hand-coded instructions above,
6391 // and adjusts them as needed.
6392
6393 template<int size, bool big_endian>
6394 void
6395 Mips_output_data_plt<size, big_endian>::do_write(Output_file* of)
6396 {
6397   const off_t offset = this->offset();
6398   const section_size_type oview_size =
6399     convert_to_section_size_type(this->data_size());
6400   unsigned char* const oview = of->get_output_view(offset, oview_size);
6401
6402   const off_t gotplt_file_offset = this->got_plt_->offset();
6403   const section_size_type gotplt_size =
6404     convert_to_section_size_type(this->got_plt_->data_size());
6405   unsigned char* const gotplt_view = of->get_output_view(gotplt_file_offset,
6406                                                          gotplt_size);
6407   unsigned char* pov = oview;
6408
6409   Mips_address plt_address = this->address();
6410
6411   // Calculate the address of .got.plt.
6412   Mips_address gotplt_addr = this->got_plt_->address();
6413   Mips_address gotplt_addr_high = ((gotplt_addr + 0x8000) >> 16) & 0xffff;
6414   Mips_address gotplt_addr_low = gotplt_addr & 0xffff;
6415
6416   // The PLT sequence is not safe for N64 if .got.plt's address can
6417   // not be loaded in two instructions.
6418   gold_assert((gotplt_addr & ~(Mips_address) 0x7fffffff) == 0
6419               || ~(gotplt_addr | 0x7fffffff) == 0);
6420
6421   // Write the PLT header.
6422   const uint32_t* plt0_entry = this->get_plt_header_entry();
6423   if (plt0_entry == plt0_entry_micromips_o32)
6424     {
6425       // Write microMIPS PLT header.
6426       gold_assert(gotplt_addr % 4 == 0);
6427
6428       Mips_address gotpc_offset = gotplt_addr - ((plt_address | 3) ^ 3);
6429
6430       // ADDIUPC has a span of +/-16MB, check we're in range.
6431       if (gotpc_offset + 0x1000000 >= 0x2000000)
6432        {
6433          gold_error(_(".got.plt offset of %ld from .plt beyond the range of "
6434                     "ADDIUPC"), (long)gotpc_offset);
6435          return;
6436        }
6437
6438       elfcpp::Swap<16, big_endian>::writeval(pov,
6439                  plt0_entry[0] | ((gotpc_offset >> 18) & 0x7f));
6440       elfcpp::Swap<16, big_endian>::writeval(pov + 2,
6441                                              (gotpc_offset >> 2) & 0xffff);
6442       pov += 4;
6443       for (unsigned int i = 2;
6444            i < (sizeof(plt0_entry_micromips_o32)
6445                 / sizeof(plt0_entry_micromips_o32[0]));
6446            i++)
6447         {
6448           elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]);
6449           pov += 2;
6450         }
6451     }
6452   else if (plt0_entry == plt0_entry_micromips32_o32)
6453     {
6454       // Write microMIPS PLT header in insn32 mode.
6455       elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[0]);
6456       elfcpp::Swap<16, big_endian>::writeval(pov + 2, gotplt_addr_high);
6457       elfcpp::Swap<16, big_endian>::writeval(pov + 4, plt0_entry[2]);
6458       elfcpp::Swap<16, big_endian>::writeval(pov + 6, gotplt_addr_low);
6459       elfcpp::Swap<16, big_endian>::writeval(pov + 8, plt0_entry[4]);
6460       elfcpp::Swap<16, big_endian>::writeval(pov + 10, gotplt_addr_low);
6461       pov += 12;
6462       for (unsigned int i = 6;
6463            i < (sizeof(plt0_entry_micromips32_o32)
6464                 / sizeof(plt0_entry_micromips32_o32[0]));
6465            i++)
6466         {
6467           elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]);
6468           pov += 2;
6469         }
6470     }
6471   else
6472     {
6473       // Write standard PLT header.
6474       elfcpp::Swap<32, big_endian>::writeval(pov,
6475                                              plt0_entry[0] | gotplt_addr_high);
6476       elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6477                                              plt0_entry[1] | gotplt_addr_low);
6478       elfcpp::Swap<32, big_endian>::writeval(pov + 8,
6479                                              plt0_entry[2] | gotplt_addr_low);
6480       pov += 12;
6481       for (int i = 3; i < 8; i++)
6482         {
6483           elfcpp::Swap<32, big_endian>::writeval(pov, plt0_entry[i]);
6484           pov += 4;
6485         }
6486     }
6487
6488
6489   unsigned char* gotplt_pov = gotplt_view;
6490   unsigned int got_entry_size = size/8; // TODO(sasa): MIPS_ELF_GOT_SIZE
6491
6492   // The first two entries in .got.plt are reserved.
6493   elfcpp::Swap<size, big_endian>::writeval(gotplt_pov, 0);
6494   elfcpp::Swap<size, big_endian>::writeval(gotplt_pov + got_entry_size, 0);
6495
6496   unsigned int gotplt_offset = 2 * got_entry_size;
6497   gotplt_pov += 2 * got_entry_size;
6498
6499   // Calculate the address of the PLT header.
6500   Mips_address header_address = (plt_address
6501                                  + (this->is_plt_header_compressed() ? 1 : 0));
6502
6503   // Initialize compressed PLT area view.
6504   unsigned char* pov2 = pov + this->plt_mips_offset_;
6505
6506   // Write the PLT entries.
6507   for (typename std::vector<Mips_symbol<size>*>::const_iterator
6508        p = this->symbols_.begin();
6509        p != this->symbols_.end();
6510        ++p, gotplt_pov += got_entry_size, gotplt_offset += got_entry_size)
6511     {
6512       Mips_symbol<size>* mips_sym = *p;
6513
6514       // Calculate the address of the .got.plt entry.
6515       uint32_t gotplt_entry_addr = (gotplt_addr + gotplt_offset);
6516       uint32_t gotplt_entry_addr_hi = (((gotplt_entry_addr + 0x8000) >> 16)
6517                                        & 0xffff);
6518       uint32_t gotplt_entry_addr_lo = gotplt_entry_addr & 0xffff;
6519
6520       // Initially point the .got.plt entry at the PLT header.
6521       if (this->target_->is_output_n64())
6522         elfcpp::Swap<64, big_endian>::writeval(gotplt_pov, header_address);
6523       else
6524         elfcpp::Swap<32, big_endian>::writeval(gotplt_pov, header_address);
6525
6526       // Now handle the PLT itself.  First the standard entry.
6527       if (mips_sym->has_mips_plt_offset())
6528         {
6529           // Pick the load opcode (LW or LD).
6530           uint64_t load = this->target_->is_output_n64() ? 0xdc000000
6531                                                          : 0x8c000000;
6532
6533           // Fill in the PLT entry itself.
6534           elfcpp::Swap<32, big_endian>::writeval(pov,
6535               plt_entry[0] | gotplt_entry_addr_hi);
6536           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6537               plt_entry[1] | gotplt_entry_addr_lo | load);
6538           elfcpp::Swap<32, big_endian>::writeval(pov + 8, plt_entry[2]);
6539           elfcpp::Swap<32, big_endian>::writeval(pov + 12,
6540               plt_entry[3] | gotplt_entry_addr_lo);
6541           pov += 16;
6542         }
6543
6544       // Now the compressed entry.  They come after any standard ones.
6545       if (mips_sym->has_comp_plt_offset())
6546         {
6547           if (!this->target_->is_output_micromips())
6548             {
6549               // Write MIPS16 PLT entry.
6550               const uint32_t* plt_entry = plt_entry_mips16_o32;
6551
6552               elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]);
6553               elfcpp::Swap<16, big_endian>::writeval(pov2 + 2, plt_entry[1]);
6554               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6555               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]);
6556               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6557               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6558               elfcpp::Swap<32, big_endian>::writeval(pov2 + 12,
6559                                                      gotplt_entry_addr);
6560               pov2 += 16;
6561             }
6562           else if (this->target_->use_32bit_micromips_instructions())
6563             {
6564               // Write microMIPS PLT entry in insn32 mode.
6565               const uint32_t* plt_entry = plt_entry_micromips32_o32;
6566
6567               elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]);
6568               elfcpp::Swap<16, big_endian>::writeval(pov2 + 2,
6569                                                      gotplt_entry_addr_hi);
6570               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6571               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6,
6572                                                      gotplt_entry_addr_lo);
6573               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6574               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6575               elfcpp::Swap<16, big_endian>::writeval(pov2 + 12, plt_entry[6]);
6576               elfcpp::Swap<16, big_endian>::writeval(pov2 + 14,
6577                                                      gotplt_entry_addr_lo);
6578               pov2 += 16;
6579             }
6580           else
6581             {
6582               // Write microMIPS PLT entry.
6583               const uint32_t* plt_entry = plt_entry_micromips_o32;
6584
6585               gold_assert(gotplt_entry_addr % 4 == 0);
6586
6587               Mips_address loc_address = plt_address + pov2 - oview;
6588               int gotpc_offset = gotplt_entry_addr - ((loc_address | 3) ^ 3);
6589
6590               // ADDIUPC has a span of +/-16MB, check we're in range.
6591               if (gotpc_offset + 0x1000000 >= 0x2000000)
6592                 {
6593                   gold_error(_(".got.plt offset of %ld from .plt beyond the "
6594                              "range of ADDIUPC"), (long)gotpc_offset);
6595                   return;
6596                 }
6597
6598               elfcpp::Swap<16, big_endian>::writeval(pov2,
6599                           plt_entry[0] | ((gotpc_offset >> 18) & 0x7f));
6600               elfcpp::Swap<16, big_endian>::writeval(
6601                   pov2 + 2, (gotpc_offset >> 2) & 0xffff);
6602               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6603               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]);
6604               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6605               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6606               pov2 += 12;
6607             }
6608         }
6609     }
6610
6611   // Check the number of bytes written for standard entries.
6612   gold_assert(static_cast<section_size_type>(
6613       pov - oview - this->plt_header_size_) == this->plt_mips_offset_);
6614   // Check the number of bytes written for compressed entries.
6615   gold_assert((static_cast<section_size_type>(pov2 - pov)
6616                == this->plt_comp_offset_));
6617   // Check the total number of bytes written.
6618   gold_assert(static_cast<section_size_type>(pov2 - oview) == oview_size);
6619
6620   gold_assert(static_cast<section_size_type>(gotplt_pov - gotplt_view)
6621               == gotplt_size);
6622
6623   of->write_output_view(offset, oview_size, oview);
6624   of->write_output_view(gotplt_file_offset, gotplt_size, gotplt_view);
6625 }
6626
6627 // Mips_output_data_mips_stubs methods.
6628
6629 // The format of the lazy binding stub when dynamic symbol count is less than
6630 // 64K, dynamic symbol index is less than 32K, and ABI is not N64.
6631 template<int size, bool big_endian>
6632 const uint32_t
6633 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1[4] =
6634 {
6635   0x8f998010,         // lw t9,0x8010(gp)
6636   0x03e07825,         // or t7,ra,zero
6637   0x0320f809,         // jalr t9,ra
6638   0x24180000          // addiu t8,zero,DYN_INDEX sign extended
6639 };
6640
6641 // The format of the lazy binding stub when dynamic symbol count is less than
6642 // 64K, dynamic symbol index is less than 32K, and ABI is N64.
6643 template<int size, bool big_endian>
6644 const uint32_t
6645 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1_n64[4] =
6646 {
6647   0xdf998010,         // ld t9,0x8010(gp)
6648   0x03e07825,         // or t7,ra,zero
6649   0x0320f809,         // jalr t9,ra
6650   0x64180000          // daddiu t8,zero,DYN_INDEX sign extended
6651 };
6652
6653 // The format of the lazy binding stub when dynamic symbol count is less than
6654 // 64K, dynamic symbol index is between 32K and 64K, and ABI is not N64.
6655 template<int size, bool big_endian>
6656 const uint32_t
6657 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2[4] =
6658 {
6659   0x8f998010,         // lw t9,0x8010(gp)
6660   0x03e07825,         // or t7,ra,zero
6661   0x0320f809,         // jalr t9,ra
6662   0x34180000          // ori t8,zero,DYN_INDEX unsigned
6663 };
6664
6665 // The format of the lazy binding stub when dynamic symbol count is less than
6666 // 64K, dynamic symbol index is between 32K and 64K, and ABI is N64.
6667 template<int size, bool big_endian>
6668 const uint32_t
6669 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2_n64[4] =
6670 {
6671   0xdf998010,         // ld t9,0x8010(gp)
6672   0x03e07825,         // or t7,ra,zero
6673   0x0320f809,         // jalr t9,ra
6674   0x34180000          // ori t8,zero,DYN_INDEX unsigned
6675 };
6676
6677 // The format of the lazy binding stub when dynamic symbol count is greater than
6678 // 64K, and ABI is not N64.
6679 template<int size, bool big_endian>
6680 const uint32_t Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big[5] =
6681 {
6682   0x8f998010,         // lw t9,0x8010(gp)
6683   0x03e07825,         // or t7,ra,zero
6684   0x3c180000,         // lui t8,DYN_INDEX
6685   0x0320f809,         // jalr t9,ra
6686   0x37180000          // ori t8,t8,DYN_INDEX
6687 };
6688
6689 // The format of the lazy binding stub when dynamic symbol count is greater than
6690 // 64K, and ABI is N64.
6691 template<int size, bool big_endian>
6692 const uint32_t
6693 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big_n64[5] =
6694 {
6695   0xdf998010,         // ld t9,0x8010(gp)
6696   0x03e07825,         // or t7,ra,zero
6697   0x3c180000,         // lui t8,DYN_INDEX
6698   0x0320f809,         // jalr t9,ra
6699   0x37180000          // ori t8,t8,DYN_INDEX
6700 };
6701
6702 // microMIPS stubs.
6703
6704 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6705 // less than 64K, dynamic symbol index is less than 32K, and ABI is not N64.
6706 template<int size, bool big_endian>
6707 const uint32_t
6708 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_1[] =
6709 {
6710   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6711   0x0dff,             // move t7,ra
6712   0x45d9,             // jalr t9
6713   0x3300, 0x0000      // addiu t8,zero,DYN_INDEX sign extended
6714 };
6715
6716 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6717 // less than 64K, dynamic symbol index is less than 32K, and ABI is N64.
6718 template<int size, bool big_endian>
6719 const uint32_t
6720 Mips_output_data_mips_stubs<size, big_endian>::
6721 lazy_stub_micromips_normal_1_n64[] =
6722 {
6723   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6724   0x0dff,             // move t7,ra
6725   0x45d9,             // jalr t9
6726   0x5f00, 0x0000      // daddiu t8,zero,DYN_INDEX sign extended
6727 };
6728
6729 // The format of the microMIPS lazy binding stub when dynamic symbol
6730 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6731 // and ABI is not N64.
6732 template<int size, bool big_endian>
6733 const uint32_t
6734 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_2[] =
6735 {
6736   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6737   0x0dff,             // move t7,ra
6738   0x45d9,             // jalr t9
6739   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6740 };
6741
6742 // The format of the microMIPS lazy binding stub when dynamic symbol
6743 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6744 // and ABI is N64.
6745 template<int size, bool big_endian>
6746 const uint32_t
6747 Mips_output_data_mips_stubs<size, big_endian>::
6748 lazy_stub_micromips_normal_2_n64[] =
6749 {
6750   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6751   0x0dff,             // move t7,ra
6752   0x45d9,             // jalr t9
6753   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6754 };
6755
6756 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6757 // greater than 64K, and ABI is not N64.
6758 template<int size, bool big_endian>
6759 const uint32_t
6760 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big[] =
6761 {
6762   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6763   0x0dff,             // move t7,ra
6764   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6765   0x45d9,             // jalr t9
6766   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6767 };
6768
6769 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6770 // greater than 64K, and ABI is N64.
6771 template<int size, bool big_endian>
6772 const uint32_t
6773 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big_n64[] =
6774 {
6775   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6776   0x0dff,             // move t7,ra
6777   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6778   0x45d9,             // jalr t9
6779   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6780 };
6781
6782 // 32-bit microMIPS stubs.
6783
6784 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6785 // less than 64K, dynamic symbol index is less than 32K, ABI is not N64, and we
6786 // can use only 32-bit instructions.
6787 template<int size, bool big_endian>
6788 const uint32_t
6789 Mips_output_data_mips_stubs<size, big_endian>::
6790 lazy_stub_micromips32_normal_1[] =
6791 {
6792   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6793   0x001f, 0x7a90,     // or t7,ra,zero
6794   0x03f9, 0x0f3c,     // jalr ra,t9
6795   0x3300, 0x0000      // addiu t8,zero,DYN_INDEX sign extended
6796 };
6797
6798 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6799 // less than 64K, dynamic symbol index is less than 32K, ABI is N64, and we can
6800 // use only 32-bit instructions.
6801 template<int size, bool big_endian>
6802 const uint32_t
6803 Mips_output_data_mips_stubs<size, big_endian>::
6804 lazy_stub_micromips32_normal_1_n64[] =
6805 {
6806   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6807   0x001f, 0x7a90,     // or t7,ra,zero
6808   0x03f9, 0x0f3c,     // jalr ra,t9
6809   0x5f00, 0x0000      // daddiu t8,zero,DYN_INDEX sign extended
6810 };
6811
6812 // The format of the microMIPS lazy binding stub when dynamic symbol
6813 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6814 // ABI is not N64, and we can use only 32-bit instructions.
6815 template<int size, bool big_endian>
6816 const uint32_t
6817 Mips_output_data_mips_stubs<size, big_endian>::
6818 lazy_stub_micromips32_normal_2[] =
6819 {
6820   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6821   0x001f, 0x7a90,     // or t7,ra,zero
6822   0x03f9, 0x0f3c,     // jalr ra,t9
6823   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6824 };
6825
6826 // The format of the microMIPS lazy binding stub when dynamic symbol
6827 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6828 // ABI is N64, and we can use only 32-bit instructions.
6829 template<int size, bool big_endian>
6830 const uint32_t
6831 Mips_output_data_mips_stubs<size, big_endian>::
6832 lazy_stub_micromips32_normal_2_n64[] =
6833 {
6834   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6835   0x001f, 0x7a90,     // or t7,ra,zero
6836   0x03f9, 0x0f3c,     // jalr ra,t9
6837   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6838 };
6839
6840 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6841 // greater than 64K, ABI is not N64, and we can use only 32-bit instructions.
6842 template<int size, bool big_endian>
6843 const uint32_t
6844 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big[] =
6845 {
6846   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6847   0x001f, 0x7a90,     // or t7,ra,zero
6848   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6849   0x03f9, 0x0f3c,     // jalr ra,t9
6850   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6851 };
6852
6853 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6854 // greater than 64K, ABI is N64, and we can use only 32-bit instructions.
6855 template<int size, bool big_endian>
6856 const uint32_t
6857 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big_n64[] =
6858 {
6859   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6860   0x001f, 0x7a90,     // or t7,ra,zero
6861   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6862   0x03f9, 0x0f3c,     // jalr ra,t9
6863   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6864 };
6865
6866 // Create entry for a symbol.
6867
6868 template<int size, bool big_endian>
6869 void
6870 Mips_output_data_mips_stubs<size, big_endian>::make_entry(
6871     Mips_symbol<size>* gsym)
6872 {
6873   if (!gsym->has_lazy_stub() && !gsym->has_plt_offset())
6874     {
6875       this->symbols_.insert(gsym);
6876       gsym->set_has_lazy_stub(true);
6877     }
6878 }
6879
6880 // Remove entry for a symbol.
6881
6882 template<int size, bool big_endian>
6883 void
6884 Mips_output_data_mips_stubs<size, big_endian>::remove_entry(
6885     Mips_symbol<size>* gsym)
6886 {
6887   if (gsym->has_lazy_stub())
6888     {
6889       this->symbols_.erase(gsym);
6890       gsym->set_has_lazy_stub(false);
6891     }
6892 }
6893
6894 // Set stub offsets for symbols.  This method expects that the number of
6895 // entries in dynamic symbol table is set.
6896
6897 template<int size, bool big_endian>
6898 void
6899 Mips_output_data_mips_stubs<size, big_endian>::set_lazy_stub_offsets()
6900 {
6901   gold_assert(this->dynsym_count_ != -1U);
6902
6903   if (this->stub_offsets_are_set_)
6904     return;
6905
6906   unsigned int stub_size = this->stub_size();
6907   unsigned int offset = 0;
6908   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6909        p = this->symbols_.begin();
6910        p != this->symbols_.end();
6911        ++p, offset += stub_size)
6912     {
6913       Mips_symbol<size>* mips_sym = *p;
6914       mips_sym->set_lazy_stub_offset(offset);
6915     }
6916   this->stub_offsets_are_set_ = true;
6917 }
6918
6919 template<int size, bool big_endian>
6920 void
6921 Mips_output_data_mips_stubs<size, big_endian>::set_needs_dynsym_value()
6922 {
6923   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6924        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6925     {
6926       Mips_symbol<size>* sym = *p;
6927       if (sym->is_from_dynobj())
6928         sym->set_needs_dynsym_value();
6929     }
6930 }
6931
6932 // Write out the .MIPS.stubs.  This uses the hand-coded instructions and
6933 // adjusts them as needed.
6934
6935 template<int size, bool big_endian>
6936 void
6937 Mips_output_data_mips_stubs<size, big_endian>::do_write(Output_file* of)
6938 {
6939   const off_t offset = this->offset();
6940   const section_size_type oview_size =
6941     convert_to_section_size_type(this->data_size());
6942   unsigned char* const oview = of->get_output_view(offset, oview_size);
6943
6944   bool big_stub = this->dynsym_count_ > 0x10000;
6945
6946   unsigned char* pov = oview;
6947   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6948        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6949     {
6950       Mips_symbol<size>* sym = *p;
6951       const uint32_t* lazy_stub;
6952       bool n64 = this->target_->is_output_n64();
6953
6954       if (!this->target_->is_output_micromips())
6955         {
6956           // Write standard (non-microMIPS) stub.
6957           if (!big_stub)
6958             {
6959               if (sym->dynsym_index() & ~0x7fff)
6960                 // Dynsym index is between 32K and 64K.
6961                 lazy_stub = n64 ? lazy_stub_normal_2_n64 : lazy_stub_normal_2;
6962               else
6963                 // Dynsym index is less than 32K.
6964                 lazy_stub = n64 ? lazy_stub_normal_1_n64 : lazy_stub_normal_1;
6965             }
6966           else
6967             lazy_stub = n64 ? lazy_stub_big_n64 : lazy_stub_big;
6968
6969           unsigned int i = 0;
6970           elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]);
6971           elfcpp::Swap<32, big_endian>::writeval(pov + 4, lazy_stub[i + 1]);
6972           pov += 8;
6973
6974           i += 2;
6975           if (big_stub)
6976             {
6977               // LUI instruction of the big stub.  Paste high 16 bits of the
6978               // dynsym index.
6979               elfcpp::Swap<32, big_endian>::writeval(pov,
6980                   lazy_stub[i] | ((sym->dynsym_index() >> 16) & 0x7fff));
6981               pov += 4;
6982               i += 1;
6983             }
6984           elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]);
6985           // Last stub instruction.  Paste low 16 bits of the dynsym index.
6986           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6987               lazy_stub[i + 1] | (sym->dynsym_index() & 0xffff));
6988           pov += 8;
6989         }
6990       else if (this->target_->use_32bit_micromips_instructions())
6991         {
6992           // Write microMIPS stub in insn32 mode.
6993           if (!big_stub)
6994             {
6995               if (sym->dynsym_index() & ~0x7fff)
6996                 // Dynsym index is between 32K and 64K.
6997                 lazy_stub = n64 ? lazy_stub_micromips32_normal_2_n64
6998                                 : lazy_stub_micromips32_normal_2;
6999               else
7000                 // Dynsym index is less than 32K.
7001                 lazy_stub = n64 ? lazy_stub_micromips32_normal_1_n64
7002                                 : lazy_stub_micromips32_normal_1;
7003             }
7004           else
7005             lazy_stub = n64 ? lazy_stub_micromips32_big_n64
7006                             : lazy_stub_micromips32_big;
7007
7008           unsigned int i = 0;
7009           // First stub instruction.  We emit 32-bit microMIPS instructions by
7010           // emitting two 16-bit parts because on microMIPS the 16-bit part of
7011           // the instruction where the opcode is must always come first, for
7012           // both little and big endian.
7013           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7014           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7015           // Second stub instruction.
7016           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7017           elfcpp::Swap<16, big_endian>::writeval(pov + 6, lazy_stub[i + 3]);
7018           pov += 8;
7019           i += 4;
7020           if (big_stub)
7021             {
7022               // LUI instruction of the big stub.  Paste high 16 bits of the
7023               // dynsym index.
7024               elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7025               elfcpp::Swap<16, big_endian>::writeval(pov + 2,
7026                   (sym->dynsym_index() >> 16) & 0x7fff);
7027               pov += 4;
7028               i += 2;
7029             }
7030           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7031           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7032           // Last stub instruction.  Paste low 16 bits of the dynsym index.
7033           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7034           elfcpp::Swap<16, big_endian>::writeval(pov + 6,
7035               sym->dynsym_index() & 0xffff);
7036           pov += 8;
7037         }
7038       else
7039         {
7040           // Write microMIPS stub.
7041           if (!big_stub)
7042             {
7043               if (sym->dynsym_index() & ~0x7fff)
7044                 // Dynsym index is between 32K and 64K.
7045                 lazy_stub = n64 ? lazy_stub_micromips_normal_2_n64
7046                                 : lazy_stub_micromips_normal_2;
7047               else
7048                 // Dynsym index is less than 32K.
7049                 lazy_stub = n64 ? lazy_stub_micromips_normal_1_n64
7050                                 : lazy_stub_micromips_normal_1;
7051             }
7052           else
7053             lazy_stub = n64 ? lazy_stub_micromips_big_n64
7054                             : lazy_stub_micromips_big;
7055
7056           unsigned int i = 0;
7057           // First stub instruction.  We emit 32-bit microMIPS instructions by
7058           // emitting two 16-bit parts because on microMIPS the 16-bit part of
7059           // the instruction where the opcode is must always come first, for
7060           // both little and big endian.
7061           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7062           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7063           // Second stub instruction.
7064           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7065           pov += 6;
7066           i += 3;
7067           if (big_stub)
7068             {
7069               // LUI instruction of the big stub.  Paste high 16 bits of the
7070               // dynsym index.
7071               elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7072               elfcpp::Swap<16, big_endian>::writeval(pov + 2,
7073                   (sym->dynsym_index() >> 16) & 0x7fff);
7074               pov += 4;
7075               i += 2;
7076             }
7077           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7078           // Last stub instruction.  Paste low 16 bits of the dynsym index.
7079           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7080           elfcpp::Swap<16, big_endian>::writeval(pov + 4,
7081               sym->dynsym_index() & 0xffff);
7082           pov += 6;
7083         }
7084     }
7085
7086   // We always allocate 20 bytes for every stub, because final dynsym count is
7087   // not known in method do_finalize_sections.  There are 4 unused bytes per
7088   // stub if final dynsym count is less than 0x10000.
7089   unsigned int used = pov - oview;
7090   unsigned int unused = big_stub ? 0 : this->symbols_.size() * 4;
7091   gold_assert(static_cast<section_size_type>(used + unused) == oview_size);
7092
7093   // Fill the unused space with zeroes.
7094   // TODO(sasa): Can we strip unused bytes during the relaxation?
7095   if (unused > 0)
7096     memset(pov, 0, unused);
7097
7098   of->write_output_view(offset, oview_size, oview);
7099 }
7100
7101 // Mips_output_section_reginfo methods.
7102
7103 template<int size, bool big_endian>
7104 void
7105 Mips_output_section_reginfo<size, big_endian>::do_write(Output_file* of)
7106 {
7107   off_t offset = this->offset();
7108   off_t data_size = this->data_size();
7109
7110   unsigned char* view = of->get_output_view(offset, data_size);
7111   elfcpp::Swap<size, big_endian>::writeval(view, this->gprmask_);
7112   elfcpp::Swap<size, big_endian>::writeval(view + 4, this->cprmask1_);
7113   elfcpp::Swap<size, big_endian>::writeval(view + 8, this->cprmask2_);
7114   elfcpp::Swap<size, big_endian>::writeval(view + 12, this->cprmask3_);
7115   elfcpp::Swap<size, big_endian>::writeval(view + 16, this->cprmask4_);
7116   // Write the gp value.
7117   elfcpp::Swap<size, big_endian>::writeval(view + 20,
7118                                            this->target_->gp_value());
7119
7120   of->write_output_view(offset, data_size, view);
7121 }
7122
7123 // Mips_copy_relocs methods.
7124
7125 // Emit any saved relocs.
7126
7127 template<int sh_type, int size, bool big_endian>
7128 void
7129 Mips_copy_relocs<sh_type, size, big_endian>::emit_mips(
7130     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section,
7131     Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target)
7132 {
7133   for (typename Copy_relocs<sh_type, size, big_endian>::
7134        Copy_reloc_entries::iterator p = this->entries_.begin();
7135        p != this->entries_.end();
7136        ++p)
7137     emit_entry(*p, reloc_section, symtab, layout, target);
7138
7139   // We no longer need the saved information.
7140   this->entries_.clear();
7141 }
7142
7143 // Emit the reloc if appropriate.
7144
7145 template<int sh_type, int size, bool big_endian>
7146 void
7147 Mips_copy_relocs<sh_type, size, big_endian>::emit_entry(
7148     Copy_reloc_entry& entry,
7149     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section,
7150     Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target)
7151 {
7152   // If the symbol is no longer defined in a dynamic object, then we
7153   // emitted a COPY relocation, and we do not want to emit this
7154   // dynamic relocation.
7155   if (!entry.sym_->is_from_dynobj())
7156     return;
7157
7158   bool can_make_dynamic = (entry.reloc_type_ == elfcpp::R_MIPS_32
7159                            || entry.reloc_type_ == elfcpp::R_MIPS_REL32
7160                            || entry.reloc_type_ == elfcpp::R_MIPS_64);
7161
7162   Mips_symbol<size>* sym = Mips_symbol<size>::as_mips_sym(entry.sym_);
7163   if (can_make_dynamic && !sym->has_static_relocs())
7164     {
7165       Mips_relobj<size, big_endian>* object =
7166         Mips_relobj<size, big_endian>::as_mips_relobj(entry.relobj_);
7167       target->got_section(symtab, layout)->record_global_got_symbol(
7168                           sym, object, entry.reloc_type_, true, false);
7169       if (!symbol_references_local(sym, sym->should_add_dynsym_entry(symtab)))
7170         target->rel_dyn_section(layout)->add_global(sym, elfcpp::R_MIPS_REL32,
7171             entry.output_section_, entry.relobj_, entry.shndx_, entry.address_);
7172       else
7173         target->rel_dyn_section(layout)->add_symbolless_global_addend(
7174             sym, elfcpp::R_MIPS_REL32, entry.output_section_, entry.relobj_,
7175             entry.shndx_, entry.address_);
7176     }
7177   else
7178     this->make_copy_reloc(symtab, layout,
7179                           static_cast<Sized_symbol<size>*>(entry.sym_),
7180                           reloc_section);
7181 }
7182
7183 // Target_mips methods.
7184
7185 // Return the value to use for a dynamic symbol which requires special
7186 // treatment.  This is how we support equality comparisons of function
7187 // pointers across shared library boundaries, as described in the
7188 // processor specific ABI supplement.
7189
7190 template<int size, bool big_endian>
7191 uint64_t
7192 Target_mips<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
7193 {
7194   uint64_t value = 0;
7195   const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
7196
7197   if (!mips_sym->has_lazy_stub())
7198     {
7199       if (mips_sym->has_plt_offset())
7200         {
7201           // We distinguish between PLT entries and lazy-binding stubs by
7202           // giving the former an st_other value of STO_MIPS_PLT.  Set the
7203           // value to the stub address if there are any relocations in the
7204           // binary where pointer equality matters.
7205           if (mips_sym->pointer_equality_needed())
7206             {
7207               // Prefer a standard MIPS PLT entry.
7208               if (mips_sym->has_mips_plt_offset())
7209                 value = this->plt_section()->mips_entry_address(mips_sym);
7210               else
7211                 value = this->plt_section()->comp_entry_address(mips_sym) + 1;
7212             }
7213           else
7214             value = 0;
7215         }
7216     }
7217   else
7218     {
7219       // First, set stub offsets for symbols.  This method expects that the
7220       // number of entries in dynamic symbol table is set.
7221       this->mips_stubs_section()->set_lazy_stub_offsets();
7222
7223       // The run-time linker uses the st_value field of the symbol
7224       // to reset the global offset table entry for this external
7225       // to its stub address when unlinking a shared object.
7226       value = this->mips_stubs_section()->stub_address(mips_sym);
7227     }
7228
7229   if (mips_sym->has_mips16_fn_stub())
7230     {
7231       // If we have a MIPS16 function with a stub, the dynamic symbol must
7232       // refer to the stub, since only the stub uses the standard calling
7233       // conventions.
7234       value = mips_sym->template
7235               get_mips16_fn_stub<big_endian>()->output_address();
7236     }
7237
7238   return value;
7239 }
7240
7241 // Get the dynamic reloc section, creating it if necessary.  It's always
7242 // .rel.dyn, even for MIPS64.
7243
7244 template<int size, bool big_endian>
7245 typename Target_mips<size, big_endian>::Reloc_section*
7246 Target_mips<size, big_endian>::rel_dyn_section(Layout* layout)
7247 {
7248   if (this->rel_dyn_ == NULL)
7249     {
7250       gold_assert(layout != NULL);
7251       this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
7252       layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
7253                                       elfcpp::SHF_ALLOC, this->rel_dyn_,
7254                                       ORDER_DYNAMIC_RELOCS, false);
7255
7256       // First entry in .rel.dyn has to be null.
7257       // This is hack - we define dummy output data and set its address to 0,
7258       // and define absolute R_MIPS_NONE relocation with offset 0 against it.
7259       // This ensures that the entry is null.
7260       Output_data* od = new Output_data_zero_fill(0, 0);
7261       od->set_address(0);
7262       this->rel_dyn_->add_absolute(elfcpp::R_MIPS_NONE, od, 0);
7263     }
7264   return this->rel_dyn_;
7265 }
7266
7267 // Get the GOT section, creating it if necessary.
7268
7269 template<int size, bool big_endian>
7270 Mips_output_data_got<size, big_endian>*
7271 Target_mips<size, big_endian>::got_section(Symbol_table* symtab,
7272                                            Layout* layout)
7273 {
7274   if (this->got_ == NULL)
7275     {
7276       gold_assert(symtab != NULL && layout != NULL);
7277
7278       this->got_ = new Mips_output_data_got<size, big_endian>(this, symtab,
7279                                                               layout);
7280       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
7281                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE |
7282                                       elfcpp::SHF_MIPS_GPREL),
7283                                       this->got_, ORDER_DATA, false);
7284
7285       // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
7286       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
7287                                     Symbol_table::PREDEFINED,
7288                                     this->got_,
7289                                     0, 0, elfcpp::STT_OBJECT,
7290                                     elfcpp::STB_GLOBAL,
7291                                     elfcpp::STV_DEFAULT, 0,
7292                                     false, false);
7293     }
7294
7295   return this->got_;
7296 }
7297
7298 // Calculate value of _gp symbol.
7299
7300 template<int size, bool big_endian>
7301 void
7302 Target_mips<size, big_endian>::set_gp(Layout* layout, Symbol_table* symtab)
7303 {
7304   if (this->gp_ != NULL)
7305     return;
7306
7307   Output_data* section = layout->find_output_section(".got");
7308   if (section == NULL)
7309     {
7310       // If there is no .got section, gp should be based on .sdata.
7311       // TODO(sasa): This is probably not needed.  This was needed for older
7312       // MIPS architectures which accessed both GOT and .sdata section using
7313       // gp-relative addressing.  Modern Mips Linux ELF architectures don't
7314       // access .sdata using gp-relative addressing.
7315       for (Layout::Section_list::const_iterator
7316            p = layout->section_list().begin();
7317            p != layout->section_list().end();
7318            ++p)
7319         {
7320           if (strcmp((*p)->name(), ".sdata") == 0)
7321             {
7322               section = *p;
7323               break;
7324             }
7325         }
7326     }
7327
7328   Sized_symbol<size>* gp =
7329     static_cast<Sized_symbol<size>*>(symtab->lookup("_gp"));
7330   if (gp != NULL)
7331     {
7332       if (gp->source() != Symbol::IS_CONSTANT && section != NULL)
7333         gp->init_output_data(gp->name(), NULL, section, MIPS_GP_OFFSET, 0,
7334                              elfcpp::STT_OBJECT,
7335                              elfcpp::STB_GLOBAL,
7336                              elfcpp::STV_DEFAULT, 0,
7337                              false, false);
7338       this->gp_ = gp;
7339     }
7340   else if (section != NULL)
7341     {
7342       gp = static_cast<Sized_symbol<size>*>(symtab->define_in_output_data(
7343                                       "_gp", NULL, Symbol_table::PREDEFINED,
7344                                       section, MIPS_GP_OFFSET, 0,
7345                                       elfcpp::STT_OBJECT,
7346                                       elfcpp::STB_GLOBAL,
7347                                       elfcpp::STV_DEFAULT,
7348                                       0, false, false));
7349       this->gp_ = gp;
7350     }
7351 }
7352
7353 // Set the dynamic symbol indexes.  INDEX is the index of the first
7354 // global dynamic symbol.  Pointers to the symbols are stored into the
7355 // vector SYMS.  The names are added to DYNPOOL.  This returns an
7356 // updated dynamic symbol index.
7357
7358 template<int size, bool big_endian>
7359 unsigned int
7360 Target_mips<size, big_endian>::do_set_dynsym_indexes(
7361     std::vector<Symbol*>* dyn_symbols, unsigned int index,
7362     std::vector<Symbol*>* syms, Stringpool* dynpool,
7363     Versions* versions, Symbol_table* symtab) const
7364 {
7365   std::vector<Symbol*> non_got_symbols;
7366   std::vector<Symbol*> got_symbols;
7367
7368   reorder_dyn_symbols<size, big_endian>(dyn_symbols, &non_got_symbols,
7369                                         &got_symbols);
7370
7371   for (std::vector<Symbol*>::iterator p = non_got_symbols.begin();
7372        p != non_got_symbols.end();
7373        ++p)
7374     {
7375       Symbol* sym = *p;
7376
7377       // Note that SYM may already have a dynamic symbol index, since
7378       // some symbols appear more than once in the symbol table, with
7379       // and without a version.
7380
7381       if (!sym->has_dynsym_index())
7382         {
7383           sym->set_dynsym_index(index);
7384           ++index;
7385           syms->push_back(sym);
7386           dynpool->add(sym->name(), false, NULL);
7387
7388           // Record any version information.
7389           if (sym->version() != NULL)
7390             versions->record_version(symtab, dynpool, sym);
7391
7392           // If the symbol is defined in a dynamic object and is
7393           // referenced in a regular object, then mark the dynamic
7394           // object as needed.  This is used to implement --as-needed.
7395           if (sym->is_from_dynobj() && sym->in_reg())
7396             sym->object()->set_is_needed();
7397         }
7398     }
7399
7400   for (std::vector<Symbol*>::iterator p = got_symbols.begin();
7401        p != got_symbols.end();
7402        ++p)
7403     {
7404       Symbol* sym = *p;
7405       if (!sym->has_dynsym_index())
7406         {
7407           // Record any version information.
7408           if (sym->version() != NULL)
7409             versions->record_version(symtab, dynpool, sym);
7410         }
7411     }
7412
7413   index = versions->finalize(symtab, index, syms);
7414
7415   int got_sym_count = 0;
7416   for (std::vector<Symbol*>::iterator p = got_symbols.begin();
7417        p != got_symbols.end();
7418        ++p)
7419     {
7420       Symbol* sym = *p;
7421
7422       if (!sym->has_dynsym_index())
7423         {
7424           ++got_sym_count;
7425           sym->set_dynsym_index(index);
7426           ++index;
7427           syms->push_back(sym);
7428           dynpool->add(sym->name(), false, NULL);
7429
7430           // If the symbol is defined in a dynamic object and is
7431           // referenced in a regular object, then mark the dynamic
7432           // object as needed.  This is used to implement --as-needed.
7433           if (sym->is_from_dynobj() && sym->in_reg())
7434             sym->object()->set_is_needed();
7435         }
7436     }
7437
7438   // Set index of the first symbol that has .got entry.
7439   this->got_->set_first_global_got_dynsym_index(
7440     got_sym_count > 0 ? index - got_sym_count : -1U);
7441
7442   if (this->mips_stubs_ != NULL)
7443     this->mips_stubs_->set_dynsym_count(index);
7444
7445   return index;
7446 }
7447
7448 // Create a PLT entry for a global symbol referenced by r_type relocation.
7449
7450 template<int size, bool big_endian>
7451 void
7452 Target_mips<size, big_endian>::make_plt_entry(Symbol_table* symtab,
7453                                               Layout* layout,
7454                                               Mips_symbol<size>* gsym,
7455                                               unsigned int r_type)
7456 {
7457   if (gsym->has_lazy_stub() || gsym->has_plt_offset())
7458     return;
7459
7460   if (this->plt_ == NULL)
7461     {
7462       // Create the GOT section first.
7463       this->got_section(symtab, layout);
7464
7465       this->got_plt_ = new Output_data_space(4, "** GOT PLT");
7466       layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
7467                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE),
7468                                       this->got_plt_, ORDER_DATA, false);
7469
7470       // The first two entries are reserved.
7471       this->got_plt_->set_current_data_size(2 * size/8);
7472
7473       this->plt_ = new Mips_output_data_plt<size, big_endian>(layout,
7474                                                               this->got_plt_,
7475                                                               this);
7476       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
7477                                       (elfcpp::SHF_ALLOC
7478                                        | elfcpp::SHF_EXECINSTR),
7479                                       this->plt_, ORDER_PLT, false);
7480     }
7481
7482   this->plt_->add_entry(gsym, r_type);
7483 }
7484
7485
7486 // Get the .MIPS.stubs section, creating it if necessary.
7487
7488 template<int size, bool big_endian>
7489 Mips_output_data_mips_stubs<size, big_endian>*
7490 Target_mips<size, big_endian>::mips_stubs_section(Layout* layout)
7491 {
7492   if (this->mips_stubs_ == NULL)
7493     {
7494       this->mips_stubs_ =
7495         new Mips_output_data_mips_stubs<size, big_endian>(this);
7496       layout->add_output_section_data(".MIPS.stubs", elfcpp::SHT_PROGBITS,
7497                                       (elfcpp::SHF_ALLOC
7498                                        | elfcpp::SHF_EXECINSTR),
7499                                       this->mips_stubs_, ORDER_PLT, false);
7500     }
7501   return this->mips_stubs_;
7502 }
7503
7504 // Get the LA25 stub section, creating it if necessary.
7505
7506 template<int size, bool big_endian>
7507 Mips_output_data_la25_stub<size, big_endian>*
7508 Target_mips<size, big_endian>::la25_stub_section(Layout* layout)
7509 {
7510   if (this->la25_stub_ == NULL)
7511     {
7512       this->la25_stub_ = new Mips_output_data_la25_stub<size, big_endian>();
7513       layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS,
7514                                       (elfcpp::SHF_ALLOC
7515                                        | elfcpp::SHF_EXECINSTR),
7516                                       this->la25_stub_, ORDER_TEXT, false);
7517     }
7518   return this->la25_stub_;
7519 }
7520
7521 // Process the relocations to determine unreferenced sections for
7522 // garbage collection.
7523
7524 template<int size, bool big_endian>
7525 void
7526 Target_mips<size, big_endian>::gc_process_relocs(
7527                         Symbol_table* symtab,
7528                         Layout* layout,
7529                         Sized_relobj_file<size, big_endian>* object,
7530                         unsigned int data_shndx,
7531                         unsigned int,
7532                         const unsigned char* prelocs,
7533                         size_t reloc_count,
7534                         Output_section* output_section,
7535                         bool needs_special_offset_handling,
7536                         size_t local_symbol_count,
7537                         const unsigned char* plocal_symbols)
7538 {
7539   typedef Target_mips<size, big_endian> Mips;
7540   typedef typename Target_mips<size, big_endian>::Scan Scan;
7541
7542   gold::gc_process_relocs<size, big_endian, Mips, elfcpp::SHT_REL, Scan,
7543                           typename Target_mips::Relocatable_size_for_reloc>(
7544     symtab,
7545     layout,
7546     this,
7547     object,
7548     data_shndx,
7549     prelocs,
7550     reloc_count,
7551     output_section,
7552     needs_special_offset_handling,
7553     local_symbol_count,
7554     plocal_symbols);
7555 }
7556
7557 // Scan relocations for a section.
7558
7559 template<int size, bool big_endian>
7560 void
7561 Target_mips<size, big_endian>::scan_relocs(
7562                         Symbol_table* symtab,
7563                         Layout* layout,
7564                         Sized_relobj_file<size, big_endian>* object,
7565                         unsigned int data_shndx,
7566                         unsigned int sh_type,
7567                         const unsigned char* prelocs,
7568                         size_t reloc_count,
7569                         Output_section* output_section,
7570                         bool needs_special_offset_handling,
7571                         size_t local_symbol_count,
7572                         const unsigned char* plocal_symbols)
7573 {
7574   typedef Target_mips<size, big_endian> Mips;
7575   typedef typename Target_mips<size, big_endian>::Scan Scan;
7576
7577   if (sh_type == elfcpp::SHT_REL)
7578     gold::scan_relocs<size, big_endian, Mips, elfcpp::SHT_REL, Scan>(
7579       symtab,
7580       layout,
7581       this,
7582       object,
7583       data_shndx,
7584       prelocs,
7585       reloc_count,
7586       output_section,
7587       needs_special_offset_handling,
7588       local_symbol_count,
7589       plocal_symbols);
7590   else if (sh_type == elfcpp::SHT_RELA)
7591     gold::scan_relocs<size, big_endian, Mips, elfcpp::SHT_RELA, Scan>(
7592       symtab,
7593       layout,
7594       this,
7595       object,
7596       data_shndx,
7597       prelocs,
7598       reloc_count,
7599       output_section,
7600       needs_special_offset_handling,
7601       local_symbol_count,
7602       plocal_symbols);
7603 }
7604
7605 template<int size, bool big_endian>
7606 bool
7607 Target_mips<size, big_endian>::mips_32bit_flags(elfcpp::Elf_Word flags)
7608 {
7609   return ((flags & elfcpp::EF_MIPS_32BITMODE) != 0
7610           || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_O32
7611           || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_EABI32
7612           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_1
7613           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_2
7614           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32
7615           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32R2);
7616 }
7617
7618 // Return the MACH for a MIPS e_flags value.
7619 template<int size, bool big_endian>
7620 unsigned int
7621 Target_mips<size, big_endian>::elf_mips_mach(elfcpp::Elf_Word flags)
7622 {
7623   switch (flags & elfcpp::EF_MIPS_MACH)
7624     {
7625     case elfcpp::E_MIPS_MACH_3900:
7626       return mach_mips3900;
7627
7628     case elfcpp::E_MIPS_MACH_4010:
7629       return mach_mips4010;
7630
7631     case elfcpp::E_MIPS_MACH_4100:
7632       return mach_mips4100;
7633
7634     case elfcpp::E_MIPS_MACH_4111:
7635       return mach_mips4111;
7636
7637     case elfcpp::E_MIPS_MACH_4120:
7638       return mach_mips4120;
7639
7640     case elfcpp::E_MIPS_MACH_4650:
7641       return mach_mips4650;
7642
7643     case elfcpp::E_MIPS_MACH_5400:
7644       return mach_mips5400;
7645
7646     case elfcpp::E_MIPS_MACH_5500:
7647       return mach_mips5500;
7648
7649     case elfcpp::E_MIPS_MACH_9000:
7650       return mach_mips9000;
7651
7652     case elfcpp::E_MIPS_MACH_SB1:
7653       return mach_mips_sb1;
7654
7655     case elfcpp::E_MIPS_MACH_LS2E:
7656       return mach_mips_loongson_2e;
7657
7658     case elfcpp::E_MIPS_MACH_LS2F:
7659       return mach_mips_loongson_2f;
7660
7661     case elfcpp::E_MIPS_MACH_LS3A:
7662       return mach_mips_loongson_3a;
7663
7664     case elfcpp::E_MIPS_MACH_OCTEON2:
7665       return mach_mips_octeon2;
7666
7667     case elfcpp::E_MIPS_MACH_OCTEON:
7668       return mach_mips_octeon;
7669
7670     case elfcpp::E_MIPS_MACH_XLR:
7671       return mach_mips_xlr;
7672
7673     default:
7674       switch (flags & elfcpp::EF_MIPS_ARCH)
7675         {
7676         default:
7677         case elfcpp::E_MIPS_ARCH_1:
7678           return mach_mips3000;
7679
7680         case elfcpp::E_MIPS_ARCH_2:
7681           return mach_mips6000;
7682
7683         case elfcpp::E_MIPS_ARCH_3:
7684           return mach_mips4000;
7685
7686         case elfcpp::E_MIPS_ARCH_4:
7687           return mach_mips8000;
7688
7689         case elfcpp::E_MIPS_ARCH_5:
7690           return mach_mips5;
7691
7692         case elfcpp::E_MIPS_ARCH_32:
7693           return mach_mipsisa32;
7694
7695         case elfcpp::E_MIPS_ARCH_64:
7696           return mach_mipsisa64;
7697
7698         case elfcpp::E_MIPS_ARCH_32R2:
7699           return mach_mipsisa32r2;
7700
7701         case elfcpp::E_MIPS_ARCH_64R2:
7702           return mach_mipsisa64r2;
7703         }
7704     }
7705
7706   return 0;
7707 }
7708
7709 // Check whether machine EXTENSION is an extension of machine BASE.
7710 template<int size, bool big_endian>
7711 bool
7712 Target_mips<size, big_endian>::mips_mach_extends(unsigned int base,
7713                                                  unsigned int extension)
7714 {
7715   if (extension == base)
7716     return true;
7717
7718   if ((base == mach_mipsisa32)
7719       && this->mips_mach_extends(mach_mipsisa64, extension))
7720     return true;
7721
7722   if ((base == mach_mipsisa32r2)
7723       && this->mips_mach_extends(mach_mipsisa64r2, extension))
7724     return true;
7725
7726   for (unsigned int i = 0; i < this->mips_mach_extensions_.size(); ++i)
7727     if (extension == this->mips_mach_extensions_[i].first)
7728       {
7729         extension = this->mips_mach_extensions_[i].second;
7730         if (extension == base)
7731           return true;
7732       }
7733
7734   return false;
7735 }
7736
7737 template<int size, bool big_endian>
7738 void
7739 Target_mips<size, big_endian>::merge_processor_specific_flags(
7740     const std::string& name, elfcpp::Elf_Word in_flags,
7741     unsigned char in_ei_class, bool dyn_obj)
7742 {
7743   // If flags are not set yet, just copy them.
7744   if (!this->are_processor_specific_flags_set())
7745     {
7746       this->set_processor_specific_flags(in_flags);
7747       this->ei_class_ = in_ei_class;
7748       this->mach_ = this->elf_mips_mach(in_flags);
7749       return;
7750     }
7751
7752   elfcpp::Elf_Word new_flags = in_flags;
7753   elfcpp::Elf_Word old_flags = this->processor_specific_flags();
7754   elfcpp::Elf_Word merged_flags = this->processor_specific_flags();
7755   merged_flags |= new_flags & elfcpp::EF_MIPS_NOREORDER;
7756
7757   // Check flag compatibility.
7758   new_flags &= ~elfcpp::EF_MIPS_NOREORDER;
7759   old_flags &= ~elfcpp::EF_MIPS_NOREORDER;
7760
7761   // Some IRIX 6 BSD-compatibility objects have this bit set.  It
7762   // doesn't seem to matter.
7763   new_flags &= ~elfcpp::EF_MIPS_XGOT;
7764   old_flags &= ~elfcpp::EF_MIPS_XGOT;
7765
7766   // MIPSpro generates ucode info in n64 objects.  Again, we should
7767   // just be able to ignore this.
7768   new_flags &= ~elfcpp::EF_MIPS_UCODE;
7769   old_flags &= ~elfcpp::EF_MIPS_UCODE;
7770
7771   // DSOs should only be linked with CPIC code.
7772   if (dyn_obj)
7773     new_flags |= elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC;
7774
7775   if (new_flags == old_flags)
7776     {
7777       this->set_processor_specific_flags(merged_flags);
7778       return;
7779     }
7780
7781   if (((new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0)
7782       != ((old_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0))
7783     gold_warning(_("%s: linking abicalls files with non-abicalls files"),
7784                  name.c_str());
7785
7786   if (new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC))
7787     merged_flags |= elfcpp::EF_MIPS_CPIC;
7788   if (!(new_flags & elfcpp::EF_MIPS_PIC))
7789     merged_flags &= ~elfcpp::EF_MIPS_PIC;
7790
7791   new_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC);
7792   old_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC);
7793
7794   // Compare the ISAs.
7795   if (mips_32bit_flags(old_flags) != mips_32bit_flags(new_flags))
7796     gold_error(_("%s: linking 32-bit code with 64-bit code"), name.c_str());
7797   else if (!this->mips_mach_extends(this->elf_mips_mach(in_flags), this->mach_))
7798     {
7799       // Output ISA isn't the same as, or an extension of, input ISA.
7800       if (this->mips_mach_extends(this->mach_, this->elf_mips_mach(in_flags)))
7801         {
7802           // Copy the architecture info from input object to output.  Also copy
7803           // the 32-bit flag (if set) so that we continue to recognise
7804           // output as a 32-bit binary.
7805           this->mach_ = this->elf_mips_mach(in_flags);
7806           merged_flags &= ~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH);
7807           merged_flags |= (new_flags & (elfcpp::EF_MIPS_ARCH
7808                            | elfcpp::EF_MIPS_MACH | elfcpp::EF_MIPS_32BITMODE));
7809
7810           // Copy across the ABI flags if output doesn't use them
7811           // and if that was what caused us to treat input object as 32-bit.
7812           if ((old_flags & elfcpp::EF_MIPS_ABI) == 0
7813               && this->mips_32bit_flags(new_flags)
7814               && !this->mips_32bit_flags(new_flags & ~elfcpp::EF_MIPS_ABI))
7815             merged_flags |= new_flags & elfcpp::EF_MIPS_ABI;
7816         }
7817       else
7818         // The ISAs aren't compatible.
7819         gold_error(_("%s: linking %s module with previous %s modules"),
7820                    name.c_str(), this->elf_mips_mach_name(in_flags),
7821                    this->elf_mips_mach_name(merged_flags));
7822     }
7823
7824   new_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH
7825                 | elfcpp::EF_MIPS_32BITMODE));
7826   old_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH
7827                 | elfcpp::EF_MIPS_32BITMODE));
7828
7829   // Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI. But, it does set
7830   // EI_CLASS differently from any 32-bit ABI.
7831   if ((new_flags & elfcpp::EF_MIPS_ABI) != (old_flags & elfcpp::EF_MIPS_ABI)
7832       || (in_ei_class != this->ei_class_))
7833     {
7834       // Only error if both are set (to different values).
7835       if (((new_flags & elfcpp::EF_MIPS_ABI)
7836            && (old_flags & elfcpp::EF_MIPS_ABI))
7837           || (in_ei_class != this->ei_class_))
7838         gold_error(_("%s: ABI mismatch: linking %s module with "
7839                      "previous %s modules"), name.c_str(),
7840                    this->elf_mips_abi_name(in_flags, in_ei_class),
7841                    this->elf_mips_abi_name(merged_flags, this->ei_class_));
7842
7843       new_flags &= ~elfcpp::EF_MIPS_ABI;
7844       old_flags &= ~elfcpp::EF_MIPS_ABI;
7845     }
7846
7847   // Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
7848   // and allow arbitrary mixing of the remaining ASEs (retain the union).
7849   if ((new_flags & elfcpp::EF_MIPS_ARCH_ASE)
7850       != (old_flags & elfcpp::EF_MIPS_ARCH_ASE))
7851     {
7852       int old_micro = old_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS;
7853       int new_micro = new_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS;
7854       int old_m16 = old_flags & elfcpp::EF_MIPS_ARCH_ASE_M16;
7855       int new_m16 = new_flags & elfcpp::EF_MIPS_ARCH_ASE_M16;
7856       int micro_mis = old_m16 && new_micro;
7857       int m16_mis = old_micro && new_m16;
7858
7859       if (m16_mis || micro_mis)
7860         gold_error(_("%s: ASE mismatch: linking %s module with "
7861                      "previous %s modules"), name.c_str(),
7862                    m16_mis ? "MIPS16" : "microMIPS",
7863                    m16_mis ? "microMIPS" : "MIPS16");
7864
7865       merged_flags |= new_flags & elfcpp::EF_MIPS_ARCH_ASE;
7866
7867       new_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE;
7868       old_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE;
7869     }
7870
7871   // Warn about any other mismatches.
7872   if (new_flags != old_flags)
7873     gold_error(_("%s: uses different e_flags (0x%x) fields than previous "
7874                  "modules (0x%x)"), name.c_str(), new_flags, old_flags);
7875
7876   this->set_processor_specific_flags(merged_flags);
7877 }
7878
7879 // Adjust ELF file header.
7880
7881 template<int size, bool big_endian>
7882 void
7883 Target_mips<size, big_endian>::do_adjust_elf_header(
7884     unsigned char* view,
7885     int len)
7886 {
7887   gold_assert(len == elfcpp::Elf_sizes<size>::ehdr_size);
7888
7889   elfcpp::Ehdr<size, big_endian> ehdr(view);
7890   unsigned char e_ident[elfcpp::EI_NIDENT];
7891   memcpy(e_ident, ehdr.get_e_ident(), elfcpp::EI_NIDENT);
7892
7893   e_ident[elfcpp::EI_CLASS] = this->ei_class_;
7894
7895   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
7896   oehdr.put_e_ident(e_ident);
7897   if (this->entry_symbol_is_compressed_)
7898     oehdr.put_e_entry(ehdr.get_e_entry() + 1);
7899 }
7900
7901 // do_make_elf_object to override the same function in the base class.
7902 // We need to use a target-specific sub-class of
7903 // Sized_relobj_file<size, big_endian> to store Mips specific information.
7904 // Hence we need to have our own ELF object creation.
7905
7906 template<int size, bool big_endian>
7907 Object*
7908 Target_mips<size, big_endian>::do_make_elf_object(
7909     const std::string& name,
7910     Input_file* input_file,
7911     off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
7912 {
7913   int et = ehdr.get_e_type();
7914   // ET_EXEC files are valid input for --just-symbols/-R,
7915   // and we treat them as relocatable objects.
7916   if (et == elfcpp::ET_REL
7917       || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
7918     {
7919       Mips_relobj<size, big_endian>* obj =
7920         new Mips_relobj<size, big_endian>(name, input_file, offset, ehdr);
7921       obj->setup();
7922       return obj;
7923     }
7924   else if (et == elfcpp::ET_DYN)
7925     {
7926       // TODO(sasa): Should we create Mips_dynobj?
7927       return Target::do_make_elf_object(name, input_file, offset, ehdr);
7928     }
7929   else
7930     {
7931       gold_error(_("%s: unsupported ELF file type %d"),
7932                  name.c_str(), et);
7933       return NULL;
7934     }
7935 }
7936
7937 // Finalize the sections.
7938
7939 template <int size, bool big_endian>
7940 void
7941 Target_mips<size, big_endian>::do_finalize_sections(Layout* layout,
7942                                         const Input_objects* input_objects,
7943                                         Symbol_table* symtab)
7944 {
7945   // Add +1 to MIPS16 and microMIPS init_ and _fini symbols so that DT_INIT and
7946   // DT_FINI have correct values.
7947   Mips_symbol<size>* init = static_cast<Mips_symbol<size>*>(
7948       symtab->lookup(parameters->options().init()));
7949   if (init != NULL && (init->is_mips16() || init->is_micromips()))
7950     init->set_value(init->value() | 1);
7951   Mips_symbol<size>* fini = static_cast<Mips_symbol<size>*>(
7952       symtab->lookup(parameters->options().fini()));
7953   if (fini != NULL && (fini->is_mips16() || fini->is_micromips()))
7954     fini->set_value(fini->value() | 1);
7955
7956   // Check whether the entry symbol is mips16 or micromips.  This is needed to
7957   // adjust entry address in ELF header.
7958   Mips_symbol<size>* entry =
7959     static_cast<Mips_symbol<size>*>(symtab->lookup(this->entry_symbol_name()));
7960   this->entry_symbol_is_compressed_ = (entry != NULL && (entry->is_mips16()
7961                                        || entry->is_micromips()));
7962
7963   if (!parameters->doing_static_link()
7964       && (strcmp(parameters->options().hash_style(), "gnu") == 0
7965           || strcmp(parameters->options().hash_style(), "both") == 0))
7966     {
7967       // .gnu.hash and the MIPS ABI require .dynsym to be sorted in different
7968       // ways.  .gnu.hash needs symbols to be grouped by hash code whereas the
7969       // MIPS ABI requires a mapping between the GOT and the symbol table.
7970       gold_error(".gnu.hash is incompatible with the MIPS ABI");
7971     }
7972
7973   // Check whether the final section that was scanned has HI16 or GOT16
7974   // relocations without the corresponding LO16 part.
7975   if (this->got16_addends_.size() > 0)
7976       gold_error("Can't find matching LO16 reloc");
7977
7978   // Set _gp value.
7979   this->set_gp(layout, symtab);
7980
7981   // Check for any mips16 stub sections that we can discard.
7982   if (!parameters->options().relocatable())
7983     {
7984       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
7985           p != input_objects->relobj_end();
7986           ++p)
7987         {
7988           Mips_relobj<size, big_endian>* object =
7989             Mips_relobj<size, big_endian>::as_mips_relobj(*p);
7990           object->discard_mips16_stub_sections(symtab);
7991         }
7992     }
7993
7994   // Merge processor-specific flags.
7995   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
7996        p != input_objects->relobj_end();
7997        ++p)
7998     {
7999       Mips_relobj<size, big_endian>* relobj =
8000         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
8001
8002       Input_file::Format format = relobj->input_file()->format();
8003       if (format == Input_file::FORMAT_ELF)
8004         {
8005           // Read processor-specific flags in ELF file header.
8006           const unsigned char* pehdr = relobj->get_view(
8007                                             elfcpp::file_header_offset,
8008                                             elfcpp::Elf_sizes<size>::ehdr_size,
8009                                             true, false);
8010
8011           elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
8012           elfcpp::Elf_Word in_flags = ehdr.get_e_flags();
8013           unsigned char ei_class = ehdr.get_e_ident()[elfcpp::EI_CLASS];
8014
8015           this->merge_processor_specific_flags(relobj->name(), in_flags,
8016                                                ei_class, false);
8017         }
8018     }
8019
8020   for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
8021        p != input_objects->dynobj_end();
8022        ++p)
8023     {
8024       Sized_dynobj<size, big_endian>* dynobj =
8025         static_cast<Sized_dynobj<size, big_endian>*>(*p);
8026
8027       // Read processor-specific flags.
8028       const unsigned char* pehdr = dynobj->get_view(elfcpp::file_header_offset,
8029                                            elfcpp::Elf_sizes<size>::ehdr_size,
8030                                            true, false);
8031
8032       elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
8033       elfcpp::Elf_Word in_flags = ehdr.get_e_flags();
8034       unsigned char ei_class = ehdr.get_e_ident()[elfcpp::EI_CLASS];
8035
8036       this->merge_processor_specific_flags(dynobj->name(), in_flags, ei_class,
8037                                            true);
8038     }
8039
8040   // Merge .reginfo contents of input objects.
8041   Valtype gprmask = 0;
8042   Valtype cprmask1 = 0;
8043   Valtype cprmask2 = 0;
8044   Valtype cprmask3 = 0;
8045   Valtype cprmask4 = 0;
8046   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
8047        p != input_objects->relobj_end();
8048        ++p)
8049     {
8050       Mips_relobj<size, big_endian>* relobj =
8051         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
8052
8053       gprmask |= relobj->gprmask();
8054       cprmask1 |= relobj->cprmask1();
8055       cprmask2 |= relobj->cprmask2();
8056       cprmask3 |= relobj->cprmask3();
8057       cprmask4 |= relobj->cprmask4();
8058     }
8059
8060   if (this->plt_ != NULL)
8061     {
8062       // Set final PLT offsets for symbols.
8063       this->plt_section()->set_plt_offsets();
8064
8065       // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
8066       // Set STO_MICROMIPS flag if the output has microMIPS code, but only if
8067       // there are no standard PLT entries present.
8068       unsigned char nonvis = 0;
8069       if (this->is_output_micromips()
8070           && !this->plt_section()->has_standard_entries())
8071         nonvis = elfcpp::STO_MICROMIPS >> 2;
8072       symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
8073                                     Symbol_table::PREDEFINED,
8074                                     this->plt_,
8075                                     0, 0, elfcpp::STT_FUNC,
8076                                     elfcpp::STB_LOCAL,
8077                                     elfcpp::STV_DEFAULT, nonvis,
8078                                     false, false);
8079     }
8080
8081   if (this->mips_stubs_ != NULL)
8082     {
8083       // Define _MIPS_STUBS_ at the start of the .MIPS.stubs section.
8084       unsigned char nonvis = 0;
8085       if (this->is_output_micromips())
8086         nonvis = elfcpp::STO_MICROMIPS >> 2;
8087       symtab->define_in_output_data("_MIPS_STUBS_", NULL,
8088                                     Symbol_table::PREDEFINED,
8089                                     this->mips_stubs_,
8090                                     0, 0, elfcpp::STT_FUNC,
8091                                     elfcpp::STB_LOCAL,
8092                                     elfcpp::STV_DEFAULT, nonvis,
8093                                     false, false);
8094     }
8095
8096   if (!parameters->options().relocatable() && !parameters->doing_static_link())
8097     // In case there is no .got section, create one.
8098     this->got_section(symtab, layout);
8099
8100   // Emit any relocs we saved in an attempt to avoid generating COPY
8101   // relocs.
8102   if (this->copy_relocs_.any_saved_relocs())
8103     this->copy_relocs_.emit_mips(this->rel_dyn_section(layout), symtab, layout,
8104                                  this);
8105
8106   // Emit dynamic relocs.
8107   for (typename std::vector<Dyn_reloc>::iterator p = this->dyn_relocs_.begin();
8108        p != this->dyn_relocs_.end();
8109        ++p)
8110     p->emit(this->rel_dyn_section(layout), this->got_section(), symtab);
8111
8112   if (this->has_got_section())
8113     this->got_section()->lay_out_got(layout, symtab, input_objects);
8114
8115   if (this->mips_stubs_ != NULL)
8116     this->mips_stubs_->set_needs_dynsym_value();
8117
8118   // Check for functions that might need $25 to be valid on entry.
8119   // TODO(sasa): Can we do this without iterating over all symbols?
8120   typedef Symbol_visitor_check_symbols<size, big_endian> Symbol_visitor;
8121   symtab->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(this, layout,
8122                                                                symtab));
8123
8124   // Add NULL segment.
8125   if (!parameters->options().relocatable())
8126     layout->make_output_segment(elfcpp::PT_NULL, 0);
8127
8128   for (Layout::Section_list::const_iterator p = layout->section_list().begin();
8129        p != layout->section_list().end();
8130        ++p)
8131     {
8132       if ((*p)->type() == elfcpp::SHT_MIPS_REGINFO)
8133         {
8134           Mips_output_section_reginfo<size, big_endian>* reginfo =
8135             Mips_output_section_reginfo<size, big_endian>::
8136               as_mips_output_section_reginfo(*p);
8137
8138           reginfo->set_masks(gprmask, cprmask1, cprmask2, cprmask3, cprmask4);
8139
8140           if (!parameters->options().relocatable())
8141             {
8142               Output_segment* reginfo_segment =
8143                 layout->make_output_segment(elfcpp::PT_MIPS_REGINFO,
8144                                             elfcpp::PF_R);
8145               reginfo_segment->add_output_section_to_nonload(reginfo,
8146                                                              elfcpp::PF_R);
8147             }
8148         }
8149     }
8150
8151   // Fill in some more dynamic tags.
8152   // TODO(sasa): Add more dynamic tags.
8153   const Reloc_section* rel_plt = (this->plt_ == NULL
8154                                   ? NULL : this->plt_->rel_plt());
8155   layout->add_target_dynamic_tags(true, this->got_, rel_plt,
8156                                   this->rel_dyn_, true, false);
8157
8158   Output_data_dynamic* const odyn = layout->dynamic_data();
8159   if (odyn != NULL
8160       && !parameters->options().relocatable()
8161       && !parameters->doing_static_link())
8162   {
8163     unsigned int d_val;
8164     // This element holds a 32-bit version id for the Runtime
8165     // Linker Interface.  This will start at integer value 1.
8166     d_val = 0x01;
8167     odyn->add_constant(elfcpp::DT_MIPS_RLD_VERSION, d_val);
8168
8169     // Dynamic flags
8170     d_val = elfcpp::RHF_NOTPOT;
8171     odyn->add_constant(elfcpp::DT_MIPS_FLAGS, d_val);
8172
8173     // Save layout for using when emiting custom dynamic tags.
8174     this->layout_ = layout;
8175
8176     // This member holds the base address of the segment.
8177     odyn->add_custom(elfcpp::DT_MIPS_BASE_ADDRESS);
8178
8179     // This member holds the number of entries in the .dynsym section.
8180     odyn->add_custom(elfcpp::DT_MIPS_SYMTABNO);
8181
8182     // This member holds the index of the first dynamic symbol
8183     // table entry that corresponds to an entry in the global offset table.
8184     odyn->add_custom(elfcpp::DT_MIPS_GOTSYM);
8185
8186     // This member holds the number of local GOT entries.
8187     odyn->add_constant(elfcpp::DT_MIPS_LOCAL_GOTNO,
8188                        this->got_->get_local_gotno());
8189
8190     if (this->plt_ != NULL)
8191       // DT_MIPS_PLTGOT dynamic tag
8192       odyn->add_section_address(elfcpp::DT_MIPS_PLTGOT, this->got_plt_);
8193   }
8194  }
8195
8196 // Get the custom dynamic tag value.
8197 template<int size, bool big_endian>
8198 unsigned int
8199 Target_mips<size, big_endian>::do_dynamic_tag_custom_value(elfcpp::DT tag) const
8200 {
8201   switch (tag)
8202     {
8203     case elfcpp::DT_MIPS_BASE_ADDRESS:
8204       {
8205         // The base address of the segment.
8206         // At this point, the segment list has been sorted into final order,
8207         // so just return vaddr of the first readable PT_LOAD segment.
8208         Output_segment* seg =
8209           this->layout_->find_output_segment(elfcpp::PT_LOAD, elfcpp::PF_R, 0);
8210         gold_assert(seg != NULL);
8211         return seg->vaddr();
8212       }
8213
8214     case elfcpp::DT_MIPS_SYMTABNO:
8215       // The number of entries in the .dynsym section.
8216       return this->get_dt_mips_symtabno();
8217
8218     case elfcpp::DT_MIPS_GOTSYM:
8219       {
8220         // The index of the first dynamic symbol table entry that corresponds
8221         // to an entry in the GOT.
8222         if (this->got_->first_global_got_dynsym_index() != -1U)
8223           return this->got_->first_global_got_dynsym_index();
8224         else
8225           // In case if we don't have global GOT symbols we default to setting
8226           // DT_MIPS_GOTSYM to the same value as DT_MIPS_SYMTABNO.
8227           return this->get_dt_mips_symtabno();
8228       }
8229
8230     default:
8231       gold_error(_("Unknown dynamic tag 0x%x"), (unsigned int)tag);
8232     }
8233
8234   return (unsigned int)-1;
8235 }
8236
8237 // Relocate section data.
8238
8239 template<int size, bool big_endian>
8240 void
8241 Target_mips<size, big_endian>::relocate_section(
8242                         const Relocate_info<size, big_endian>* relinfo,
8243                         unsigned int sh_type,
8244                         const unsigned char* prelocs,
8245                         size_t reloc_count,
8246                         Output_section* output_section,
8247                         bool needs_special_offset_handling,
8248                         unsigned char* view,
8249                         Mips_address address,
8250                         section_size_type view_size,
8251                         const Reloc_symbol_changes* reloc_symbol_changes)
8252 {
8253   typedef Target_mips<size, big_endian> Mips;
8254   typedef typename Target_mips<size, big_endian>::Relocate Mips_relocate;
8255
8256   if (sh_type == elfcpp::SHT_REL)
8257     gold::relocate_section<size, big_endian, Mips, elfcpp::SHT_REL,
8258       Mips_relocate, gold::Default_comdat_behavior>(
8259       relinfo,
8260       this,
8261       prelocs,
8262       reloc_count,
8263       output_section,
8264       needs_special_offset_handling,
8265       view,
8266       address,
8267       view_size,
8268       reloc_symbol_changes);
8269   else if (sh_type == elfcpp::SHT_RELA)
8270     gold::relocate_section<size, big_endian, Mips, elfcpp::SHT_RELA,
8271       Mips_relocate, gold::Default_comdat_behavior>(
8272       relinfo,
8273       this,
8274       prelocs,
8275       reloc_count,
8276       output_section,
8277       needs_special_offset_handling,
8278       view,
8279       address,
8280       view_size,
8281      reloc_symbol_changes);
8282 }
8283
8284 // Return the size of a relocation while scanning during a relocatable
8285 // link.
8286
8287 template<int size, bool big_endian>
8288 unsigned int
8289 Target_mips<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
8290     unsigned int r_type,
8291     Relobj* object)
8292 {
8293   switch (r_type)
8294     {
8295     case elfcpp::R_MIPS_NONE:
8296     case elfcpp::R_MIPS_TLS_DTPMOD64:
8297     case elfcpp::R_MIPS_TLS_DTPREL64:
8298     case elfcpp::R_MIPS_TLS_TPREL64:
8299       return 0;
8300
8301     case elfcpp::R_MIPS_32:
8302     case elfcpp::R_MIPS_TLS_DTPMOD32:
8303     case elfcpp::R_MIPS_TLS_DTPREL32:
8304     case elfcpp::R_MIPS_TLS_TPREL32:
8305     case elfcpp::R_MIPS_REL32:
8306     case elfcpp::R_MIPS_PC32:
8307     case elfcpp::R_MIPS_GPREL32:
8308     case elfcpp::R_MIPS_JALR:
8309       return 4;
8310
8311     case elfcpp::R_MIPS_16:
8312     case elfcpp::R_MIPS_HI16:
8313     case elfcpp::R_MIPS_LO16:
8314     case elfcpp::R_MIPS_GPREL16:
8315     case elfcpp::R_MIPS16_HI16:
8316     case elfcpp::R_MIPS16_LO16:
8317     case elfcpp::R_MIPS_PC16:
8318     case elfcpp::R_MIPS_GOT16:
8319     case elfcpp::R_MIPS16_GOT16:
8320     case elfcpp::R_MIPS_CALL16:
8321     case elfcpp::R_MIPS16_CALL16:
8322     case elfcpp::R_MIPS_GOT_HI16:
8323     case elfcpp::R_MIPS_CALL_HI16:
8324     case elfcpp::R_MIPS_GOT_LO16:
8325     case elfcpp::R_MIPS_CALL_LO16:
8326     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
8327     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
8328     case elfcpp::R_MIPS_TLS_TPREL_HI16:
8329     case elfcpp::R_MIPS_TLS_TPREL_LO16:
8330     case elfcpp::R_MIPS16_GPREL:
8331     case elfcpp::R_MIPS_GOT_DISP:
8332     case elfcpp::R_MIPS_LITERAL:
8333     case elfcpp::R_MIPS_GOT_PAGE:
8334     case elfcpp::R_MIPS_GOT_OFST:
8335     case elfcpp::R_MIPS_TLS_GD:
8336     case elfcpp::R_MIPS_TLS_LDM:
8337     case elfcpp::R_MIPS_TLS_GOTTPREL:
8338       return 2;
8339
8340     // These relocations are not byte sized
8341     case elfcpp::R_MIPS_26:
8342     case elfcpp::R_MIPS16_26:
8343       return 4;
8344
8345     case elfcpp::R_MIPS_COPY:
8346     case elfcpp::R_MIPS_JUMP_SLOT:
8347       object->error(_("unexpected reloc %u in object file"), r_type);
8348       return 0;
8349
8350     default:
8351       object->error(_("unsupported reloc %u in object file"), r_type);
8352       return 0;
8353   }
8354 }
8355
8356 // Scan the relocs during a relocatable link.
8357
8358 template<int size, bool big_endian>
8359 void
8360 Target_mips<size, big_endian>::scan_relocatable_relocs(
8361                         Symbol_table* symtab,
8362                         Layout* layout,
8363                         Sized_relobj_file<size, big_endian>* object,
8364                         unsigned int data_shndx,
8365                         unsigned int sh_type,
8366                         const unsigned char* prelocs,
8367                         size_t reloc_count,
8368                         Output_section* output_section,
8369                         bool needs_special_offset_handling,
8370                         size_t local_symbol_count,
8371                         const unsigned char* plocal_symbols,
8372                         Relocatable_relocs* rr)
8373 {
8374   gold_assert(sh_type == elfcpp::SHT_REL);
8375
8376   typedef Mips_scan_relocatable_relocs<big_endian, elfcpp::SHT_REL,
8377     Relocatable_size_for_reloc> Scan_relocatable_relocs;
8378
8379   gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_REL,
8380     Scan_relocatable_relocs>(
8381     symtab,
8382     layout,
8383     object,
8384     data_shndx,
8385     prelocs,
8386     reloc_count,
8387     output_section,
8388     needs_special_offset_handling,
8389     local_symbol_count,
8390     plocal_symbols,
8391     rr);
8392 }
8393
8394 // Emit relocations for a section.
8395
8396 template<int size, bool big_endian>
8397 void
8398 Target_mips<size, big_endian>::relocate_relocs(
8399                         const Relocate_info<size, big_endian>* relinfo,
8400                         unsigned int sh_type,
8401                         const unsigned char* prelocs,
8402                         size_t reloc_count,
8403                         Output_section* output_section,
8404                         typename elfcpp::Elf_types<size>::Elf_Off
8405                           offset_in_output_section,
8406                         const Relocatable_relocs* rr,
8407                         unsigned char* view,
8408                         Mips_address view_address,
8409                         section_size_type view_size,
8410                         unsigned char* reloc_view,
8411                         section_size_type reloc_view_size)
8412 {
8413   gold_assert(sh_type == elfcpp::SHT_REL);
8414
8415   gold::relocate_relocs<size, big_endian, elfcpp::SHT_REL>(
8416     relinfo,
8417     prelocs,
8418     reloc_count,
8419     output_section,
8420     offset_in_output_section,
8421     rr,
8422     view,
8423     view_address,
8424     view_size,
8425     reloc_view,
8426     reloc_view_size);
8427 }
8428
8429 // Perform target-specific processing in a relocatable link.  This is
8430 // only used if we use the relocation strategy RELOC_SPECIAL.
8431
8432 template<int size, bool big_endian>
8433 void
8434 Target_mips<size, big_endian>::relocate_special_relocatable(
8435     const Relocate_info<size, big_endian>* relinfo,
8436     unsigned int sh_type,
8437     const unsigned char* preloc_in,
8438     size_t relnum,
8439     Output_section* output_section,
8440     typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
8441     unsigned char* view,
8442     Mips_address view_address,
8443     section_size_type,
8444     unsigned char* preloc_out)
8445 {
8446   // We can only handle REL type relocation sections.
8447   gold_assert(sh_type == elfcpp::SHT_REL);
8448
8449   typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc
8450     Reltype;
8451   typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc_write
8452     Reltype_write;
8453
8454   typedef Mips_relocate_functions<size, big_endian> Reloc_funcs;
8455
8456   const Mips_address invalid_address = static_cast<Mips_address>(0) - 1;
8457
8458   Mips_relobj<size, big_endian>* object =
8459     Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object);
8460   const unsigned int local_count = object->local_symbol_count();
8461
8462   Reltype reloc(preloc_in);
8463   Reltype_write reloc_write(preloc_out);
8464
8465   elfcpp::Elf_types<32>::Elf_WXword r_info = reloc.get_r_info();
8466   const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8467   const unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
8468
8469   // Get the new symbol index.
8470   // We only use RELOC_SPECIAL strategy in local relocations.
8471   gold_assert(r_sym < local_count);
8472
8473   // We are adjusting a section symbol.  We need to find
8474   // the symbol table index of the section symbol for
8475   // the output section corresponding to input section
8476   // in which this symbol is defined.
8477   bool is_ordinary;
8478   unsigned int shndx = object->local_symbol_input_shndx(r_sym, &is_ordinary);
8479   gold_assert(is_ordinary);
8480   Output_section* os = object->output_section(shndx);
8481   gold_assert(os != NULL);
8482   gold_assert(os->needs_symtab_index());
8483   unsigned int new_symndx = os->symtab_index();
8484
8485   // Get the new offset--the location in the output section where
8486   // this relocation should be applied.
8487
8488   Mips_address offset = reloc.get_r_offset();
8489   Mips_address new_offset;
8490   if (offset_in_output_section != invalid_address)
8491     new_offset = offset + offset_in_output_section;
8492   else
8493     {
8494       section_offset_type sot_offset =
8495         convert_types<section_offset_type, Mips_address>(offset);
8496       section_offset_type new_sot_offset =
8497         output_section->output_offset(object, relinfo->data_shndx,
8498                                       sot_offset);
8499       gold_assert(new_sot_offset != -1);
8500       new_offset = new_sot_offset;
8501     }
8502
8503   // In an object file, r_offset is an offset within the section.
8504   // In an executable or dynamic object, generated by
8505   // --emit-relocs, r_offset is an absolute address.
8506   if (!parameters->options().relocatable())
8507     {
8508       new_offset += view_address;
8509       if (offset_in_output_section != invalid_address)
8510         new_offset -= offset_in_output_section;
8511     }
8512
8513   reloc_write.put_r_offset(new_offset);
8514   reloc_write.put_r_info(elfcpp::elf_r_info<32>(new_symndx, r_type));
8515
8516   // Handle the reloc addend.
8517   // The relocation uses a section symbol in the input file.
8518   // We are adjusting it to use a section symbol in the output
8519   // file.  The input section symbol refers to some address in
8520   // the input section.  We need the relocation in the output
8521   // file to refer to that same address.  This adjustment to
8522   // the addend is the same calculation we use for a simple
8523   // absolute relocation for the input section symbol.
8524
8525   const Symbol_value<size>* psymval = object->local_symbol(r_sym);
8526
8527   unsigned char* paddend = view + offset;
8528   typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY;
8529   switch (r_type)
8530     {
8531     case elfcpp::R_MIPS_26:
8532       reloc_status = Reloc_funcs::rel26(paddend, object, psymval,
8533           offset_in_output_section, true, 0, sh_type == elfcpp::SHT_REL, NULL,
8534           false /*TODO(sasa): cross mode jump*/, r_type, this->jal_to_bal());
8535       break;
8536
8537     default:
8538       gold_unreachable();
8539     }
8540
8541   // Report any errors.
8542   switch (reloc_status)
8543     {
8544     case Reloc_funcs::STATUS_OKAY:
8545       break;
8546     case Reloc_funcs::STATUS_OVERFLOW:
8547       gold_error_at_location(relinfo, relnum, reloc.get_r_offset(),
8548                              _("relocation overflow"));
8549       break;
8550     case Reloc_funcs::STATUS_BAD_RELOC:
8551       gold_error_at_location(relinfo, relnum, reloc.get_r_offset(),
8552         _("unexpected opcode while processing relocation"));
8553       break;
8554     default:
8555       gold_unreachable();
8556     }
8557 }
8558
8559 // Optimize the TLS relocation type based on what we know about the
8560 // symbol.  IS_FINAL is true if the final address of this symbol is
8561 // known at link time.
8562
8563 template<int size, bool big_endian>
8564 tls::Tls_optimization
8565 Target_mips<size, big_endian>::optimize_tls_reloc(bool, int)
8566 {
8567   // FIXME: Currently we do not do any TLS optimization.
8568   return tls::TLSOPT_NONE;
8569 }
8570
8571 // Scan a relocation for a local symbol.
8572
8573 template<int size, bool big_endian>
8574 inline void
8575 Target_mips<size, big_endian>::Scan::local(
8576                         Symbol_table* symtab,
8577                         Layout* layout,
8578                         Target_mips<size, big_endian>* target,
8579                         Sized_relobj_file<size, big_endian>* object,
8580                         unsigned int data_shndx,
8581                         Output_section* output_section,
8582                         const elfcpp::Rela<size, big_endian>* rela,
8583                         const elfcpp::Rel<size, big_endian>* rel,
8584                         unsigned int rel_type,
8585                         unsigned int r_type,
8586                         const elfcpp::Sym<size, big_endian>& lsym,
8587                         bool is_discarded)
8588 {
8589   if (is_discarded)
8590     return;
8591
8592   Mips_address r_offset;
8593   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
8594   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
8595
8596   if (rel_type == elfcpp::SHT_RELA)
8597     {
8598       r_offset = rela->get_r_offset();
8599       r_info = rela->get_r_info();
8600       r_addend = rela->get_r_addend();
8601     }
8602   else
8603     {
8604       r_offset = rel->get_r_offset();
8605       r_info = rel->get_r_info();
8606       r_addend = 0;
8607     }
8608
8609   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8610   Mips_relobj<size, big_endian>* mips_obj =
8611     Mips_relobj<size, big_endian>::as_mips_relobj(object);
8612
8613   if (mips_obj->is_mips16_stub_section(data_shndx))
8614     {
8615       mips_obj->get_mips16_stub_section(data_shndx)
8616               ->new_local_reloc_found(r_type, r_sym);
8617     }
8618
8619   if (r_type == elfcpp::R_MIPS_NONE)
8620     // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
8621     // mips16 stub.
8622     return;
8623
8624   if (!mips16_call_reloc(r_type)
8625       && !mips_obj->section_allows_mips16_refs(data_shndx))
8626     // This reloc would need to refer to a MIPS16 hard-float stub, if
8627     // there is one.  We ignore MIPS16 stub sections and .pdr section when
8628     // looking for relocs that would need to refer to MIPS16 stubs.
8629     mips_obj->add_local_non_16bit_call(r_sym);
8630
8631   if (r_type == elfcpp::R_MIPS16_26
8632       && !mips_obj->section_allows_mips16_refs(data_shndx))
8633     mips_obj->add_local_16bit_call(r_sym);
8634
8635   switch (r_type)
8636     {
8637     case elfcpp::R_MIPS_GOT16:
8638     case elfcpp::R_MIPS_CALL16:
8639     case elfcpp::R_MIPS_CALL_HI16:
8640     case elfcpp::R_MIPS_CALL_LO16:
8641     case elfcpp::R_MIPS_GOT_HI16:
8642     case elfcpp::R_MIPS_GOT_LO16:
8643     case elfcpp::R_MIPS_GOT_PAGE:
8644     case elfcpp::R_MIPS_GOT_OFST:
8645     case elfcpp::R_MIPS_GOT_DISP:
8646     case elfcpp::R_MIPS_TLS_GOTTPREL:
8647     case elfcpp::R_MIPS_TLS_GD:
8648     case elfcpp::R_MIPS_TLS_LDM:
8649     case elfcpp::R_MIPS16_GOT16:
8650     case elfcpp::R_MIPS16_CALL16:
8651     case elfcpp::R_MIPS16_TLS_GOTTPREL:
8652     case elfcpp::R_MIPS16_TLS_GD:
8653     case elfcpp::R_MIPS16_TLS_LDM:
8654     case elfcpp::R_MICROMIPS_GOT16:
8655     case elfcpp::R_MICROMIPS_CALL16:
8656     case elfcpp::R_MICROMIPS_CALL_HI16:
8657     case elfcpp::R_MICROMIPS_CALL_LO16:
8658     case elfcpp::R_MICROMIPS_GOT_HI16:
8659     case elfcpp::R_MICROMIPS_GOT_LO16:
8660     case elfcpp::R_MICROMIPS_GOT_PAGE:
8661     case elfcpp::R_MICROMIPS_GOT_OFST:
8662     case elfcpp::R_MICROMIPS_GOT_DISP:
8663     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8664     case elfcpp::R_MICROMIPS_TLS_GD:
8665     case elfcpp::R_MICROMIPS_TLS_LDM:
8666       // We need a GOT section.
8667       target->got_section(symtab, layout);
8668       break;
8669
8670     default:
8671       break;
8672     }
8673
8674   if (call_lo16_reloc(r_type)
8675       || got_lo16_reloc(r_type)
8676       || got_disp_reloc(r_type))
8677     {
8678       // We may need a local GOT entry for this relocation.  We
8679       // don't count R_MIPS_GOT_PAGE because we can estimate the
8680       // maximum number of pages needed by looking at the size of
8681       // the segment.  Similar comments apply to R_MIPS*_GOT16 and
8682       // R_MIPS*_CALL16.  We don't count R_MIPS_GOT_HI16, or
8683       // R_MIPS_CALL_HI16 because these are always followed by an
8684       // R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
8685       Mips_output_data_got<size, big_endian>* got =
8686         target->got_section(symtab, layout);
8687       unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8688       got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type, -1U);
8689     }
8690
8691   switch (r_type)
8692     {
8693     case elfcpp::R_MIPS_CALL16:
8694     case elfcpp::R_MIPS16_CALL16:
8695     case elfcpp::R_MICROMIPS_CALL16:
8696       gold_error(_("CALL16 reloc at 0x%lx not against global symbol "),
8697                  (unsigned long)r_offset);
8698       return;
8699
8700     case elfcpp::R_MIPS_GOT_PAGE:
8701     case elfcpp::R_MICROMIPS_GOT_PAGE:
8702     case elfcpp::R_MIPS16_GOT16:
8703     case elfcpp::R_MIPS_GOT16:
8704     case elfcpp::R_MIPS_GOT_HI16:
8705     case elfcpp::R_MIPS_GOT_LO16:
8706     case elfcpp::R_MICROMIPS_GOT16:
8707     case elfcpp::R_MICROMIPS_GOT_HI16:
8708     case elfcpp::R_MICROMIPS_GOT_LO16:
8709       {
8710         // This relocation needs a page entry in the GOT.
8711         // Get the section contents.
8712         section_size_type view_size = 0;
8713         const unsigned char* view = object->section_contents(data_shndx,
8714                                                              &view_size, false);
8715         view += r_offset;
8716
8717         Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
8718         Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff
8719                                                         : r_addend);
8720
8721         if (rel_type == elfcpp::SHT_REL && got16_reloc(r_type))
8722           target->got16_addends_.push_back(got16_addend<size, big_endian>(
8723               object, data_shndx, r_type, r_sym, addend));
8724         else
8725           target->got_section()->record_got_page_entry(mips_obj, r_sym, addend);
8726         break;
8727       }
8728
8729     case elfcpp::R_MIPS_HI16:
8730     case elfcpp::R_MIPS16_HI16:
8731     case elfcpp::R_MICROMIPS_HI16:
8732       // Record the reloc so that we can check whether the corresponding LO16
8733       // part exists.
8734       if (rel_type == elfcpp::SHT_REL)
8735         target->got16_addends_.push_back(got16_addend<size, big_endian>(
8736             object, data_shndx, r_type, r_sym, 0));
8737       break;
8738
8739     case elfcpp::R_MIPS_LO16:
8740     case elfcpp::R_MIPS16_LO16:
8741     case elfcpp::R_MICROMIPS_LO16:
8742       {
8743         if (rel_type != elfcpp::SHT_REL)
8744           break;
8745
8746         // Find corresponding GOT16/HI16 relocation.
8747
8748         // According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8749         // be immediately following.  However, for the IRIX6 ABI, the next
8750         // relocation may be a composed relocation consisting of several
8751         // relocations for the same address.  In that case, the R_MIPS_LO16
8752         // relocation may occur as one of these.  We permit a similar
8753         // extension in general, as that is useful for GCC.
8754
8755         // In some cases GCC dead code elimination removes the LO16 but
8756         // keeps the corresponding HI16.  This is strictly speaking a
8757         // violation of the ABI but not immediately harmful.
8758
8759         typename std::list<got16_addend<size, big_endian> >::iterator it =
8760           target->got16_addends_.begin();
8761         while (it != target->got16_addends_.end())
8762           {
8763             got16_addend<size, big_endian> _got16_addend = *it;
8764
8765             // TODO(sasa): Split got16_addends_ list into two lists - one for
8766             // GOT16 relocs and the other for HI16 relocs.
8767
8768             // Report an error if we find HI16 or GOT16 reloc from the
8769             // previous section without the matching LO16 part.
8770             if (_got16_addend.object != object
8771                 || _got16_addend.shndx != data_shndx)
8772               {
8773                 gold_error("Can't find matching LO16 reloc");
8774                 break;
8775               }
8776
8777             if (_got16_addend.r_sym != r_sym
8778                 || !is_matching_lo16_reloc(_got16_addend.r_type, r_type))
8779               {
8780                 ++it;
8781                 continue;
8782               }
8783
8784             // We found a matching HI16 or GOT16 reloc for this LO16 reloc.
8785             // For GOT16, we need to calculate combined addend and record GOT page
8786             // entry.
8787             if (got16_reloc(_got16_addend.r_type))
8788               {
8789
8790                 section_size_type view_size = 0;
8791                 const unsigned char* view = object->section_contents(data_shndx,
8792                                                                      &view_size,
8793                                                                      false);
8794                 view += r_offset;
8795
8796                 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
8797                 int32_t addend = Bits<16>::sign_extend32(val & 0xffff);
8798
8799                 addend = (_got16_addend.addend << 16) + addend;
8800                 target->got_section()->record_got_page_entry(mips_obj, r_sym,
8801                                                              addend);
8802               }
8803
8804             it = target->got16_addends_.erase(it);
8805           }
8806         break;
8807       }
8808     }
8809
8810   switch (r_type)
8811     {
8812     case elfcpp::R_MIPS_32:
8813     case elfcpp::R_MIPS_REL32:
8814     case elfcpp::R_MIPS_64:
8815       {
8816         if (parameters->options().output_is_position_independent())
8817           {
8818             // If building a shared library (or a position-independent
8819             // executable), we need to create a dynamic relocation for
8820             // this location.
8821             Reloc_section* rel_dyn = target->rel_dyn_section(layout);
8822             unsigned int r_sym = elfcpp::elf_r_sym<32>(r_info);
8823             rel_dyn->add_symbolless_local_addend(object, r_sym,
8824                                                  elfcpp::R_MIPS_REL32,
8825                                                  output_section, data_shndx,
8826                                                  r_offset);
8827           }
8828         break;
8829       }
8830
8831     case elfcpp::R_MIPS_TLS_GOTTPREL:
8832     case elfcpp::R_MIPS16_TLS_GOTTPREL:
8833     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8834     case elfcpp::R_MIPS_TLS_LDM:
8835     case elfcpp::R_MIPS16_TLS_LDM:
8836     case elfcpp::R_MICROMIPS_TLS_LDM:
8837     case elfcpp::R_MIPS_TLS_GD:
8838     case elfcpp::R_MIPS16_TLS_GD:
8839     case elfcpp::R_MICROMIPS_TLS_GD:
8840       {
8841         unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8842         bool output_is_shared = parameters->options().shared();
8843         const tls::Tls_optimization optimized_type
8844             = Target_mips<size, big_endian>::optimize_tls_reloc(
8845                                              !output_is_shared, r_type);
8846         switch (r_type)
8847           {
8848           case elfcpp::R_MIPS_TLS_GD:
8849           case elfcpp::R_MIPS16_TLS_GD:
8850           case elfcpp::R_MICROMIPS_TLS_GD:
8851             if (optimized_type == tls::TLSOPT_NONE)
8852               {
8853                 // Create a pair of GOT entries for the module index and
8854                 // dtv-relative offset.
8855                 Mips_output_data_got<size, big_endian>* got =
8856                   target->got_section(symtab, layout);
8857                 unsigned int shndx = lsym.get_st_shndx();
8858                 bool is_ordinary;
8859                 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
8860                 if (!is_ordinary)
8861                   {
8862                     object->error(_("local symbol %u has bad shndx %u"),
8863                                   r_sym, shndx);
8864                     break;
8865                   }
8866                 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type,
8867                                              shndx);
8868               }
8869             else
8870               {
8871                 // FIXME: TLS optimization not supported yet.
8872                 gold_unreachable();
8873               }
8874             break;
8875
8876           case elfcpp::R_MIPS_TLS_LDM:
8877           case elfcpp::R_MIPS16_TLS_LDM:
8878           case elfcpp::R_MICROMIPS_TLS_LDM:
8879             if (optimized_type == tls::TLSOPT_NONE)
8880               {
8881                 // We always record LDM symbols as local with index 0.
8882                 target->got_section()->record_local_got_symbol(mips_obj, 0,
8883                                                                r_addend, r_type,
8884                                                                -1U);
8885               }
8886             else
8887               {
8888                 // FIXME: TLS optimization not supported yet.
8889                 gold_unreachable();
8890               }
8891             break;
8892           case elfcpp::R_MIPS_TLS_GOTTPREL:
8893           case elfcpp::R_MIPS16_TLS_GOTTPREL:
8894           case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8895             layout->set_has_static_tls();
8896             if (optimized_type == tls::TLSOPT_NONE)
8897               {
8898                 // Create a GOT entry for the tp-relative offset.
8899                 Mips_output_data_got<size, big_endian>* got =
8900                   target->got_section(symtab, layout);
8901                 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type,
8902                                              -1U);
8903               }
8904             else
8905               {
8906                 // FIXME: TLS optimization not supported yet.
8907                 gold_unreachable();
8908               }
8909             break;
8910
8911           default:
8912             gold_unreachable();
8913         }
8914       }
8915       break;
8916
8917     default:
8918       break;
8919     }
8920
8921   // Refuse some position-dependent relocations when creating a
8922   // shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
8923   // not PIC, but we can create dynamic relocations and the result
8924   // will be fine.  Also do not refuse R_MIPS_LO16, which can be
8925   // combined with R_MIPS_GOT16.
8926   if (parameters->options().shared())
8927     {
8928       switch (r_type)
8929         {
8930         case elfcpp::R_MIPS16_HI16:
8931         case elfcpp::R_MIPS_HI16:
8932         case elfcpp::R_MICROMIPS_HI16:
8933           // Don't refuse a high part relocation if it's against
8934           // no symbol (e.g. part of a compound relocation).
8935           if (r_sym == 0)
8936             break;
8937
8938           // FALLTHROUGH
8939
8940         case elfcpp::R_MIPS16_26:
8941         case elfcpp::R_MIPS_26:
8942         case elfcpp::R_MICROMIPS_26_S1:
8943           gold_error(_("%s: relocation %u against `%s' can not be used when "
8944                        "making a shared object; recompile with -fPIC"),
8945                      object->name().c_str(), r_type, "a local symbol");
8946         default:
8947           break;
8948         }
8949     }
8950 }
8951
8952 template<int size, bool big_endian>
8953 inline void
8954 Target_mips<size, big_endian>::Scan::local(
8955                         Symbol_table* symtab,
8956                         Layout* layout,
8957                         Target_mips<size, big_endian>* target,
8958                         Sized_relobj_file<size, big_endian>* object,
8959                         unsigned int data_shndx,
8960                         Output_section* output_section,
8961                         const elfcpp::Rel<size, big_endian>& reloc,
8962                         unsigned int r_type,
8963                         const elfcpp::Sym<size, big_endian>& lsym,
8964                         bool is_discarded)
8965 {
8966   if (is_discarded)
8967     return;
8968
8969   local(
8970     symtab,
8971     layout,
8972     target,
8973     object,
8974     data_shndx,
8975     output_section,
8976     (const elfcpp::Rela<size, big_endian>*) NULL,
8977     &reloc,
8978     elfcpp::SHT_REL,
8979     r_type,
8980     lsym, is_discarded);
8981 }
8982
8983
8984 template<int size, bool big_endian>
8985 inline void
8986 Target_mips<size, big_endian>::Scan::local(
8987                         Symbol_table* symtab,
8988                         Layout* layout,
8989                         Target_mips<size, big_endian>* target,
8990                         Sized_relobj_file<size, big_endian>* object,
8991                         unsigned int data_shndx,
8992                         Output_section* output_section,
8993                         const elfcpp::Rela<size, big_endian>& reloc,
8994                         unsigned int r_type,
8995                         const elfcpp::Sym<size, big_endian>& lsym,
8996                         bool is_discarded)
8997 {
8998   if (is_discarded)
8999     return;
9000
9001   local(
9002     symtab,
9003     layout,
9004     target,
9005     object,
9006     data_shndx,
9007     output_section,
9008     &reloc,
9009     (const elfcpp::Rel<size, big_endian>*) NULL,
9010     elfcpp::SHT_RELA,
9011     r_type,
9012     lsym, is_discarded);
9013 }
9014
9015 // Scan a relocation for a global symbol.
9016
9017 template<int size, bool big_endian>
9018 inline void
9019 Target_mips<size, big_endian>::Scan::global(
9020                                 Symbol_table* symtab,
9021                                 Layout* layout,
9022                                 Target_mips<size, big_endian>* target,
9023                                 Sized_relobj_file<size, big_endian>* object,
9024                                 unsigned int data_shndx,
9025                                 Output_section* output_section,
9026                                 const elfcpp::Rela<size, big_endian>* rela,
9027                                 const elfcpp::Rel<size, big_endian>* rel,
9028                                 unsigned int rel_type,
9029                                 unsigned int r_type,
9030                                 Symbol* gsym)
9031 {
9032   Mips_address r_offset;
9033   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
9034   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
9035
9036   if (rel_type == elfcpp::SHT_RELA)
9037     {
9038       r_offset = rela->get_r_offset();
9039       r_info = rela->get_r_info();
9040       r_addend = rela->get_r_addend();
9041     }
9042   else
9043     {
9044       r_offset = rel->get_r_offset();
9045       r_info = rel->get_r_info();
9046       r_addend = 0;
9047     }
9048
9049   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
9050   Mips_relobj<size, big_endian>* mips_obj =
9051     Mips_relobj<size, big_endian>::as_mips_relobj(object);
9052   Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
9053
9054   if (mips_obj->is_mips16_stub_section(data_shndx))
9055     {
9056       mips_obj->get_mips16_stub_section(data_shndx)
9057               ->new_global_reloc_found(r_type, mips_sym);
9058     }
9059
9060   if (r_type == elfcpp::R_MIPS_NONE)
9061     // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
9062     // mips16 stub.
9063     return;
9064
9065   if (!mips16_call_reloc(r_type)
9066       && !mips_obj->section_allows_mips16_refs(data_shndx))
9067     // This reloc would need to refer to a MIPS16 hard-float stub, if
9068     // there is one.  We ignore MIPS16 stub sections and .pdr section when
9069     // looking for relocs that would need to refer to MIPS16 stubs.
9070     mips_sym->set_need_fn_stub();
9071
9072   // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
9073   // section.  We check here to avoid creating a dynamic reloc against
9074   // _GLOBAL_OFFSET_TABLE_.
9075   if (!target->has_got_section()
9076       && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
9077     target->got_section(symtab, layout);
9078
9079   // We need PLT entries if there are static-only relocations against
9080   // an externally-defined function.  This can technically occur for
9081   // shared libraries if there are branches to the symbol, although it
9082   // is unlikely that this will be used in practice due to the short
9083   // ranges involved.  It can occur for any relative or absolute relocation
9084   // in executables; in that case, the PLT entry becomes the function's
9085   // canonical address.
9086   bool static_reloc = false;
9087
9088   // Set CAN_MAKE_DYNAMIC to true if we can convert this
9089   // relocation into a dynamic one.
9090   bool can_make_dynamic = false;
9091   switch (r_type)
9092     {
9093     case elfcpp::R_MIPS_GOT16:
9094     case elfcpp::R_MIPS_CALL16:
9095     case elfcpp::R_MIPS_CALL_HI16:
9096     case elfcpp::R_MIPS_CALL_LO16:
9097     case elfcpp::R_MIPS_GOT_HI16:
9098     case elfcpp::R_MIPS_GOT_LO16:
9099     case elfcpp::R_MIPS_GOT_PAGE:
9100     case elfcpp::R_MIPS_GOT_OFST:
9101     case elfcpp::R_MIPS_GOT_DISP:
9102     case elfcpp::R_MIPS_TLS_GOTTPREL:
9103     case elfcpp::R_MIPS_TLS_GD:
9104     case elfcpp::R_MIPS_TLS_LDM:
9105     case elfcpp::R_MIPS16_GOT16:
9106     case elfcpp::R_MIPS16_CALL16:
9107     case elfcpp::R_MIPS16_TLS_GOTTPREL:
9108     case elfcpp::R_MIPS16_TLS_GD:
9109     case elfcpp::R_MIPS16_TLS_LDM:
9110     case elfcpp::R_MICROMIPS_GOT16:
9111     case elfcpp::R_MICROMIPS_CALL16:
9112     case elfcpp::R_MICROMIPS_CALL_HI16:
9113     case elfcpp::R_MICROMIPS_CALL_LO16:
9114     case elfcpp::R_MICROMIPS_GOT_HI16:
9115     case elfcpp::R_MICROMIPS_GOT_LO16:
9116     case elfcpp::R_MICROMIPS_GOT_PAGE:
9117     case elfcpp::R_MICROMIPS_GOT_OFST:
9118     case elfcpp::R_MICROMIPS_GOT_DISP:
9119     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9120     case elfcpp::R_MICROMIPS_TLS_GD:
9121     case elfcpp::R_MICROMIPS_TLS_LDM:
9122       // We need a GOT section.
9123       target->got_section(symtab, layout);
9124       break;
9125
9126     // This is just a hint; it can safely be ignored.  Don't set
9127     // has_static_relocs for the corresponding symbol.
9128     case elfcpp::R_MIPS_JALR:
9129     case elfcpp::R_MICROMIPS_JALR:
9130       break;
9131
9132     case elfcpp::R_MIPS_GPREL16:
9133     case elfcpp::R_MIPS_GPREL32:
9134     case elfcpp::R_MIPS16_GPREL:
9135     case elfcpp::R_MICROMIPS_GPREL16:
9136       // TODO(sasa)
9137       // GP-relative relocations always resolve to a definition in a
9138       // regular input file, ignoring the one-definition rule.  This is
9139       // important for the GP setup sequence in NewABI code, which
9140       // always resolves to a local function even if other relocations
9141       // against the symbol wouldn't.
9142       //constrain_symbol_p = FALSE;
9143       break;
9144
9145     case elfcpp::R_MIPS_32:
9146     case elfcpp::R_MIPS_REL32:
9147     case elfcpp::R_MIPS_64:
9148       if (parameters->options().shared()
9149           || strcmp(gsym->name(), "__gnu_local_gp") != 0)
9150         {
9151           if (r_type != elfcpp::R_MIPS_REL32)
9152             {
9153               static_reloc = true;
9154               mips_sym->set_pointer_equality_needed();
9155             }
9156           can_make_dynamic = true;
9157           break;
9158         }
9159       // Fall through.
9160
9161     default:
9162       // Most static relocations require pointer equality, except
9163       // for branches.
9164       mips_sym->set_pointer_equality_needed();
9165
9166       // Fall through.
9167
9168     case elfcpp::R_MIPS_26:
9169     case elfcpp::R_MIPS_PC16:
9170     case elfcpp::R_MIPS16_26:
9171     case elfcpp::R_MICROMIPS_26_S1:
9172     case elfcpp::R_MICROMIPS_PC7_S1:
9173     case elfcpp::R_MICROMIPS_PC10_S1:
9174     case elfcpp::R_MICROMIPS_PC16_S1:
9175     case elfcpp::R_MICROMIPS_PC23_S2:
9176       static_reloc = true;
9177       mips_sym->set_has_static_relocs();
9178       break;
9179     }
9180
9181   // If there are call relocations against an externally-defined symbol,
9182   // see whether we can create a MIPS lazy-binding stub for it.  We can
9183   // only do this if all references to the function are through call
9184   // relocations, and in that case, the traditional lazy-binding stubs
9185   // are much more efficient than PLT entries.
9186   switch (r_type)
9187     {
9188     case elfcpp::R_MIPS16_CALL16:
9189     case elfcpp::R_MIPS_CALL16:
9190     case elfcpp::R_MIPS_CALL_HI16:
9191     case elfcpp::R_MIPS_CALL_LO16:
9192     case elfcpp::R_MIPS_JALR:
9193     case elfcpp::R_MICROMIPS_CALL16:
9194     case elfcpp::R_MICROMIPS_CALL_HI16:
9195     case elfcpp::R_MICROMIPS_CALL_LO16:
9196     case elfcpp::R_MICROMIPS_JALR:
9197       if (!mips_sym->no_lazy_stub())
9198         {
9199           if ((mips_sym->needs_plt_entry() && mips_sym->is_from_dynobj())
9200               // Calls from shared objects to undefined symbols of type
9201               // STT_NOTYPE need lazy-binding stub.
9202               || (mips_sym->is_undefined() && parameters->options().shared()))
9203             target->mips_stubs_section(layout)->make_entry(mips_sym);
9204         }
9205       break;
9206     default:
9207       {
9208         // We must not create a stub for a symbol that has relocations
9209         // related to taking the function's address.
9210         mips_sym->set_no_lazy_stub();
9211         target->remove_lazy_stub_entry(mips_sym);
9212         break;
9213       }
9214   }
9215
9216   if (relocation_needs_la25_stub<size, big_endian>(mips_obj, r_type,
9217                                                    mips_sym->is_mips16()))
9218     mips_sym->set_has_nonpic_branches();
9219
9220   // R_MIPS_HI16 against _gp_disp is used for $gp setup,
9221   // and has a special meaning.
9222   bool gp_disp_against_hi16 = (!mips_obj->is_newabi()
9223                                && strcmp(gsym->name(), "_gp_disp") == 0
9224                                && (hi16_reloc(r_type) || lo16_reloc(r_type)));
9225   if (static_reloc && gsym->needs_plt_entry())
9226     {
9227       target->make_plt_entry(symtab, layout, mips_sym, r_type);
9228
9229       // Since this is not a PC-relative relocation, we may be
9230       // taking the address of a function.  In that case we need to
9231       // set the entry in the dynamic symbol table to the address of
9232       // the PLT entry.
9233       if (gsym->is_from_dynobj() && !parameters->options().shared())
9234         {
9235           gsym->set_needs_dynsym_value();
9236           // We distinguish between PLT entries and lazy-binding stubs by
9237           // giving the former an st_other value of STO_MIPS_PLT.  Set the
9238           // flag if there are any relocations in the binary where pointer
9239           // equality matters.
9240           if (mips_sym->pointer_equality_needed())
9241             mips_sym->set_mips_plt();
9242         }
9243     }
9244   if ((static_reloc || can_make_dynamic) && !gp_disp_against_hi16)
9245     {
9246       // Absolute addressing relocations.
9247       // Make a dynamic relocation if necessary.
9248       if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
9249         {
9250           if (gsym->may_need_copy_reloc())
9251             {
9252               target->copy_reloc(symtab, layout, object,
9253                                  data_shndx, output_section, gsym, *rel);
9254             }
9255           else if (can_make_dynamic)
9256             {
9257               // Create .rel.dyn section.
9258               target->rel_dyn_section(layout);
9259               target->dynamic_reloc(mips_sym, elfcpp::R_MIPS_REL32, mips_obj,
9260                                     data_shndx, output_section, r_offset);
9261             }
9262           else
9263             gold_error(_("non-dynamic relocations refer to dynamic symbol %s"),
9264                        gsym->name());
9265         }
9266     }
9267
9268   bool for_call = false;
9269   switch (r_type)
9270     {
9271     case elfcpp::R_MIPS_CALL16:
9272     case elfcpp::R_MIPS16_CALL16:
9273     case elfcpp::R_MICROMIPS_CALL16:
9274     case elfcpp::R_MIPS_CALL_HI16:
9275     case elfcpp::R_MIPS_CALL_LO16:
9276     case elfcpp::R_MICROMIPS_CALL_HI16:
9277     case elfcpp::R_MICROMIPS_CALL_LO16:
9278       for_call = true;
9279       // Fall through.
9280
9281     case elfcpp::R_MIPS16_GOT16:
9282     case elfcpp::R_MIPS_GOT16:
9283     case elfcpp::R_MIPS_GOT_HI16:
9284     case elfcpp::R_MIPS_GOT_LO16:
9285     case elfcpp::R_MICROMIPS_GOT16:
9286     case elfcpp::R_MICROMIPS_GOT_HI16:
9287     case elfcpp::R_MICROMIPS_GOT_LO16:
9288     case elfcpp::R_MIPS_GOT_DISP:
9289     case elfcpp::R_MICROMIPS_GOT_DISP:
9290       {
9291         // The symbol requires a GOT entry.
9292         Mips_output_data_got<size, big_endian>* got =
9293           target->got_section(symtab, layout);
9294         got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9295                                       for_call);
9296         mips_sym->set_global_got_area(GGA_NORMAL);
9297       }
9298       break;
9299
9300     case elfcpp::R_MIPS_GOT_PAGE:
9301     case elfcpp::R_MICROMIPS_GOT_PAGE:
9302       {
9303         // This relocation needs a page entry in the GOT.
9304         // Get the section contents.
9305         section_size_type view_size = 0;
9306         const unsigned char* view =
9307           object->section_contents(data_shndx, &view_size, false);
9308         view += r_offset;
9309
9310         Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
9311         Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff
9312                                                         : r_addend);
9313         Mips_output_data_got<size, big_endian>* got =
9314           target->got_section(symtab, layout);
9315         got->record_got_page_entry(mips_obj, r_sym, addend);
9316
9317         // If this is a global, overridable symbol, GOT_PAGE will
9318         // decay to GOT_DISP, so we'll need a GOT entry for it.
9319         bool def_regular = (mips_sym->source() == Symbol::FROM_OBJECT
9320                             && !mips_sym->object()->is_dynamic()
9321                             && !mips_sym->is_undefined());
9322         if (!def_regular
9323             || (parameters->options().output_is_position_independent()
9324                 && !parameters->options().Bsymbolic()
9325                 && !mips_sym->is_forced_local()))
9326           {
9327             got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9328                                           for_call);
9329             mips_sym->set_global_got_area(GGA_NORMAL);
9330           }
9331       }
9332       break;
9333
9334     case elfcpp::R_MIPS_TLS_GOTTPREL:
9335     case elfcpp::R_MIPS16_TLS_GOTTPREL:
9336     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9337     case elfcpp::R_MIPS_TLS_LDM:
9338     case elfcpp::R_MIPS16_TLS_LDM:
9339     case elfcpp::R_MICROMIPS_TLS_LDM:
9340     case elfcpp::R_MIPS_TLS_GD:
9341     case elfcpp::R_MIPS16_TLS_GD:
9342     case elfcpp::R_MICROMIPS_TLS_GD:
9343       {
9344         const bool is_final = gsym->final_value_is_known();
9345         const tls::Tls_optimization optimized_type =
9346           Target_mips<size, big_endian>::optimize_tls_reloc(is_final, r_type);
9347
9348         switch (r_type)
9349           {
9350           case elfcpp::R_MIPS_TLS_GD:
9351           case elfcpp::R_MIPS16_TLS_GD:
9352           case elfcpp::R_MICROMIPS_TLS_GD:
9353             if (optimized_type == tls::TLSOPT_NONE)
9354               {
9355                 // Create a pair of GOT entries for the module index and
9356                 // dtv-relative offset.
9357                 Mips_output_data_got<size, big_endian>* got =
9358                   target->got_section(symtab, layout);
9359                 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9360                                               false);
9361               }
9362             else
9363               {
9364                 // FIXME: TLS optimization not supported yet.
9365                 gold_unreachable();
9366               }
9367             break;
9368
9369           case elfcpp::R_MIPS_TLS_LDM:
9370           case elfcpp::R_MIPS16_TLS_LDM:
9371           case elfcpp::R_MICROMIPS_TLS_LDM:
9372             if (optimized_type == tls::TLSOPT_NONE)
9373               {
9374                 // We always record LDM symbols as local with index 0.
9375                 target->got_section()->record_local_got_symbol(mips_obj, 0,
9376                                                                r_addend, r_type,
9377                                                                -1U);
9378               }
9379             else
9380               {
9381                 // FIXME: TLS optimization not supported yet.
9382                 gold_unreachable();
9383               }
9384             break;
9385           case elfcpp::R_MIPS_TLS_GOTTPREL:
9386           case elfcpp::R_MIPS16_TLS_GOTTPREL:
9387           case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9388             layout->set_has_static_tls();
9389             if (optimized_type == tls::TLSOPT_NONE)
9390               {
9391                 // Create a GOT entry for the tp-relative offset.
9392                 Mips_output_data_got<size, big_endian>* got =
9393                   target->got_section(symtab, layout);
9394                 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9395                                               false);
9396               }
9397             else
9398               {
9399                 // FIXME: TLS optimization not supported yet.
9400                 gold_unreachable();
9401               }
9402             break;
9403
9404           default:
9405             gold_unreachable();
9406         }
9407       }
9408       break;
9409     case elfcpp::R_MIPS_COPY:
9410     case elfcpp::R_MIPS_JUMP_SLOT:
9411       // These are relocations which should only be seen by the
9412       // dynamic linker, and should never be seen here.
9413       gold_error(_("%s: unexpected reloc %u in object file"),
9414                  object->name().c_str(), r_type);
9415       break;
9416
9417     default:
9418       break;
9419     }
9420
9421   // Refuse some position-dependent relocations when creating a
9422   // shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
9423   // not PIC, but we can create dynamic relocations and the result
9424   // will be fine.  Also do not refuse R_MIPS_LO16, which can be
9425   // combined with R_MIPS_GOT16.
9426   if (parameters->options().shared())
9427     {
9428       switch (r_type)
9429         {
9430         case elfcpp::R_MIPS16_HI16:
9431         case elfcpp::R_MIPS_HI16:
9432         case elfcpp::R_MICROMIPS_HI16:
9433           // Don't refuse a high part relocation if it's against
9434           // no symbol (e.g. part of a compound relocation).
9435           if (r_sym == 0)
9436             break;
9437
9438           // R_MIPS_HI16 against _gp_disp is used for $gp setup,
9439           // and has a special meaning.
9440           if (!mips_obj->is_newabi() && strcmp(gsym->name(), "_gp_disp") == 0)
9441             break;
9442
9443           // FALLTHROUGH
9444
9445         case elfcpp::R_MIPS16_26:
9446         case elfcpp::R_MIPS_26:
9447         case elfcpp::R_MICROMIPS_26_S1:
9448           gold_error(_("%s: relocation %u against `%s' can not be used when "
9449                        "making a shared object; recompile with -fPIC"),
9450                      object->name().c_str(), r_type, gsym->name());
9451         default:
9452           break;
9453         }
9454     }
9455 }
9456
9457 template<int size, bool big_endian>
9458 inline void
9459 Target_mips<size, big_endian>::Scan::global(
9460                                 Symbol_table* symtab,
9461                                 Layout* layout,
9462                                 Target_mips<size, big_endian>* target,
9463                                 Sized_relobj_file<size, big_endian>* object,
9464                                 unsigned int data_shndx,
9465                                 Output_section* output_section,
9466                                 const elfcpp::Rela<size, big_endian>& reloc,
9467                                 unsigned int r_type,
9468                                 Symbol* gsym)
9469 {
9470   global(
9471     symtab,
9472     layout,
9473     target,
9474     object,
9475     data_shndx,
9476     output_section,
9477     &reloc,
9478     (const elfcpp::Rel<size, big_endian>*) NULL,
9479     elfcpp::SHT_RELA,
9480     r_type,
9481     gsym);
9482 }
9483
9484 template<int size, bool big_endian>
9485 inline void
9486 Target_mips<size, big_endian>::Scan::global(
9487                                 Symbol_table* symtab,
9488                                 Layout* layout,
9489                                 Target_mips<size, big_endian>* target,
9490                                 Sized_relobj_file<size, big_endian>* object,
9491                                 unsigned int data_shndx,
9492                                 Output_section* output_section,
9493                                 const elfcpp::Rel<size, big_endian>& reloc,
9494                                 unsigned int r_type,
9495                                 Symbol* gsym)
9496 {
9497   global(
9498     symtab,
9499     layout,
9500     target,
9501     object,
9502     data_shndx,
9503     output_section,
9504     (const elfcpp::Rela<size, big_endian>*) NULL,
9505     &reloc,
9506     elfcpp::SHT_REL,
9507     r_type,
9508     gsym);
9509 }
9510
9511 // Return whether a R_MIPS_32 relocation needs to be applied.
9512
9513 template<int size, bool big_endian>
9514 inline bool
9515 Target_mips<size, big_endian>::Relocate::should_apply_r_mips_32_reloc(
9516     const Mips_symbol<size>* gsym,
9517     unsigned int r_type,
9518     Output_section* output_section,
9519     Target_mips* target)
9520 {
9521   // If the output section is not allocated, then we didn't call
9522   // scan_relocs, we didn't create a dynamic reloc, and we must apply
9523   // the reloc here.
9524   if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0)
9525       return true;
9526
9527   if (gsym == NULL)
9528     return true;
9529   else
9530     {
9531       // For global symbols, we use the same helper routines used in the
9532       // scan pass.
9533       if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))
9534           && !gsym->may_need_copy_reloc())
9535         {
9536           // We have generated dynamic reloc (R_MIPS_REL32).
9537
9538           bool multi_got = false;
9539           if (target->has_got_section())
9540             multi_got = target->got_section()->multi_got();
9541           bool has_got_offset;
9542           if (!multi_got)
9543             has_got_offset = gsym->has_got_offset(GOT_TYPE_STANDARD);
9544           else
9545             has_got_offset = gsym->global_gotoffset() != -1U;
9546           if (!has_got_offset)
9547             return true;
9548           else
9549             // Apply the relocation only if the symbol is in the local got.
9550             // Do not apply the relocation if the symbol is in the global
9551             // got.
9552             return symbol_references_local(gsym, gsym->has_dynsym_index());
9553         }
9554       else
9555         // We have not generated dynamic reloc.
9556         return true;
9557     }
9558 }
9559
9560 // Perform a relocation.
9561
9562 template<int size, bool big_endian>
9563 inline bool
9564 Target_mips<size, big_endian>::Relocate::relocate(
9565                         const Relocate_info<size, big_endian>* relinfo,
9566                         Target_mips* target,
9567                         Output_section* output_section,
9568                         size_t relnum,
9569                         const elfcpp::Rela<size, big_endian>* rela,
9570                         const elfcpp::Rel<size, big_endian>* rel,
9571                         unsigned int rel_type,
9572                         unsigned int r_type,
9573                         const Sized_symbol<size>* gsym,
9574                         const Symbol_value<size>* psymval,
9575                         unsigned char* view,
9576                         Mips_address address,
9577                         section_size_type)
9578 {
9579   Mips_address r_offset;
9580   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
9581   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
9582
9583   if (rel_type == elfcpp::SHT_RELA)
9584     {
9585       r_offset = rela->get_r_offset();
9586       r_info = rela->get_r_info();
9587       r_addend = rela->get_r_addend();
9588     }
9589   else
9590     {
9591       r_offset = rel->get_r_offset();
9592       r_info = rel->get_r_info();
9593       r_addend = 0;
9594     }
9595
9596   typedef Mips_relocate_functions<size, big_endian> Reloc_funcs;
9597   typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY;
9598
9599   Mips_relobj<size, big_endian>* object =
9600     Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object);
9601
9602   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
9603   bool target_is_16_bit_code = false;
9604   bool target_is_micromips_code = false;
9605   bool cross_mode_jump;
9606
9607   Symbol_value<size> symval;
9608
9609   const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
9610
9611   bool changed_symbol_value = false;
9612   if (gsym == NULL)
9613     {
9614       target_is_16_bit_code = object->local_symbol_is_mips16(r_sym);
9615       target_is_micromips_code = object->local_symbol_is_micromips(r_sym);
9616       if (target_is_16_bit_code || target_is_micromips_code)
9617         {
9618           // MIPS16/microMIPS text labels should be treated as odd.
9619           symval.set_output_value(psymval->value(object, 1));
9620           psymval = &symval;
9621           changed_symbol_value = true;
9622         }
9623     }
9624   else
9625     {
9626       target_is_16_bit_code = mips_sym->is_mips16();
9627       target_is_micromips_code = mips_sym->is_micromips();
9628
9629       // If this is a mips16/microMIPS text symbol, add 1 to the value to make
9630       // it odd.  This will cause something like .word SYM to come up with
9631       // the right value when it is loaded into the PC.
9632
9633       if ((mips_sym->is_mips16() || mips_sym->is_micromips())
9634           && psymval->value(object, 0) != 0)
9635         {
9636           symval.set_output_value(psymval->value(object, 0) | 1);
9637           psymval = &symval;
9638           changed_symbol_value = true;
9639         }
9640
9641       // Pick the value to use for symbols defined in shared objects.
9642       if (mips_sym->use_plt_offset(Scan::get_reference_flags(r_type))
9643           || mips_sym->has_lazy_stub())
9644         {
9645           Mips_address value;
9646           if (!mips_sym->has_lazy_stub())
9647             {
9648               // Prefer a standard MIPS PLT entry.
9649               if (mips_sym->has_mips_plt_offset())
9650                 {
9651                   value = target->plt_section()->mips_entry_address(mips_sym);
9652                   target_is_micromips_code = false;
9653                   target_is_16_bit_code = false;
9654                 }
9655               else
9656                 {
9657                   value = (target->plt_section()->comp_entry_address(mips_sym)
9658                            + 1);
9659                   if (target->is_output_micromips())
9660                     target_is_micromips_code = true;
9661                   else
9662                     target_is_16_bit_code = true;
9663                 }
9664             }
9665           else
9666             value = target->mips_stubs_section()->stub_address(mips_sym);
9667
9668           symval.set_output_value(value);
9669           psymval = &symval;
9670         }
9671     }
9672
9673   // TRUE if the symbol referred to by this relocation is "_gp_disp".
9674   // Note that such a symbol must always be a global symbol.
9675   bool gp_disp = (gsym != NULL && (strcmp(gsym->name(), "_gp_disp") == 0)
9676                   && !object->is_newabi());
9677
9678   // TRUE if the symbol referred to by this relocation is "__gnu_local_gp".
9679   // Note that such a symbol must always be a global symbol.
9680   bool gnu_local_gp = gsym && (strcmp(gsym->name(), "__gnu_local_gp") == 0);
9681
9682
9683   if (gp_disp)
9684     {
9685       if (!hi16_reloc(r_type) && !lo16_reloc(r_type))
9686         gold_error_at_location(relinfo, relnum, r_offset,
9687           _("relocations against _gp_disp are permitted only"
9688             " with R_MIPS_HI16 and R_MIPS_LO16 relocations."));
9689     }
9690   else if (gnu_local_gp)
9691     {
9692       // __gnu_local_gp is _gp symbol.
9693       symval.set_output_value(target->adjusted_gp_value(object));
9694       psymval = &symval;
9695     }
9696
9697   // If this is a reference to a 16-bit function with a stub, we need
9698   // to redirect the relocation to the stub unless:
9699   //
9700   // (a) the relocation is for a MIPS16 JAL;
9701   //
9702   // (b) the relocation is for a MIPS16 PIC call, and there are no
9703   //     non-MIPS16 uses of the GOT slot; or
9704   //
9705   // (c) the section allows direct references to MIPS16 functions.
9706   if (r_type != elfcpp::R_MIPS16_26
9707       && !parameters->options().relocatable()
9708       && ((mips_sym != NULL
9709            && mips_sym->has_mips16_fn_stub()
9710            && (r_type != elfcpp::R_MIPS16_CALL16 || mips_sym->need_fn_stub()))
9711           || (mips_sym == NULL
9712               && object->get_local_mips16_fn_stub(r_sym) != NULL))
9713       && !object->section_allows_mips16_refs(relinfo->data_shndx))
9714     {
9715       // This is a 32- or 64-bit call to a 16-bit function.  We should
9716       // have already noticed that we were going to need the
9717       // stub.
9718       Mips_address value;
9719       if (mips_sym == NULL)
9720         value = object->get_local_mips16_fn_stub(r_sym)->output_address();
9721       else
9722         {
9723           gold_assert(mips_sym->need_fn_stub());
9724           if (mips_sym->has_la25_stub())
9725             value = target->la25_stub_section()->stub_address(mips_sym);
9726           else
9727             {
9728               value = mips_sym->template
9729                       get_mips16_fn_stub<big_endian>()->output_address();
9730             }
9731           }
9732       symval.set_output_value(value);
9733       psymval = &symval;
9734       changed_symbol_value = true;
9735
9736       // The target is 16-bit, but the stub isn't.
9737       target_is_16_bit_code = false;
9738     }
9739   // If this is a MIPS16 call with a stub, that is made through the PLT or
9740   // to a standard MIPS function, we need to redirect the call to the stub.
9741   // Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
9742   // indirect calls should use an indirect stub instead.
9743   else if (r_type == elfcpp::R_MIPS16_26 && !parameters->options().relocatable()
9744            && ((mips_sym != NULL
9745                 && (mips_sym->has_mips16_call_stub()
9746                     || mips_sym->has_mips16_call_fp_stub()))
9747                || (mips_sym == NULL
9748                    && object->get_local_mips16_call_stub(r_sym) != NULL))
9749            && ((mips_sym != NULL && mips_sym->has_plt_offset())
9750                || !target_is_16_bit_code))
9751     {
9752       Mips16_stub_section<size, big_endian>* call_stub;
9753       if (mips_sym == NULL)
9754         call_stub = object->get_local_mips16_call_stub(r_sym);
9755       else
9756         {
9757           // If both call_stub and call_fp_stub are defined, we can figure
9758           // out which one to use by checking which one appears in the input
9759           // file.
9760           if (mips_sym->has_mips16_call_stub()
9761               && mips_sym->has_mips16_call_fp_stub())
9762             {
9763               call_stub = NULL;
9764               for (unsigned int i = 1; i < object->shnum(); ++i)
9765                 {
9766                   if (object->is_mips16_call_fp_stub_section(i))
9767                     {
9768                       call_stub = mips_sym->template
9769                                   get_mips16_call_fp_stub<big_endian>();
9770                       break;
9771                     }
9772
9773                 }
9774               if (call_stub == NULL)
9775                 call_stub =
9776                   mips_sym->template get_mips16_call_stub<big_endian>();
9777             }
9778           else if (mips_sym->has_mips16_call_stub())
9779             call_stub = mips_sym->template get_mips16_call_stub<big_endian>();
9780           else
9781             call_stub = mips_sym->template get_mips16_call_fp_stub<big_endian>();
9782         }
9783
9784       symval.set_output_value(call_stub->output_address());
9785       psymval = &symval;
9786       changed_symbol_value = true;
9787     }
9788   // If this is a direct call to a PIC function, redirect to the
9789   // non-PIC stub.
9790   else if (mips_sym != NULL
9791            && mips_sym->has_la25_stub()
9792            && relocation_needs_la25_stub<size, big_endian>(
9793                                        object, r_type, target_is_16_bit_code))
9794     {
9795       Mips_address value = target->la25_stub_section()->stub_address(mips_sym);
9796       if (mips_sym->is_micromips())
9797         value += 1;
9798       symval.set_output_value(value);
9799       psymval = &symval;
9800     }
9801   // For direct MIPS16 and microMIPS calls make sure the compressed PLT
9802   // entry is used if a standard PLT entry has also been made.
9803   else if ((r_type == elfcpp::R_MIPS16_26
9804             || r_type == elfcpp::R_MICROMIPS_26_S1)
9805           && !parameters->options().relocatable()
9806           && mips_sym != NULL
9807           && mips_sym->has_plt_offset()
9808           && mips_sym->has_comp_plt_offset()
9809           && mips_sym->has_mips_plt_offset())
9810     {
9811       Mips_address value = (target->plt_section()->comp_entry_address(mips_sym)
9812                             + 1);
9813       symval.set_output_value(value);
9814       psymval = &symval;
9815
9816       target_is_16_bit_code = !target->is_output_micromips();
9817       target_is_micromips_code = target->is_output_micromips();
9818     }
9819
9820   // Make sure MIPS16 and microMIPS are not used together.
9821   if ((r_type == elfcpp::R_MIPS16_26 && target_is_micromips_code)
9822       || (micromips_branch_reloc(r_type) && target_is_16_bit_code))
9823    {
9824       gold_error(_("MIPS16 and microMIPS functions cannot call each other"));
9825    }
9826
9827   // Calls from 16-bit code to 32-bit code and vice versa require the
9828   // mode change.  However, we can ignore calls to undefined weak symbols,
9829   // which should never be executed at runtime.  This exception is important
9830   // because the assembly writer may have "known" that any definition of the
9831   // symbol would be 16-bit code, and that direct jumps were therefore
9832   // acceptable.
9833   cross_mode_jump =
9834     (!parameters->options().relocatable()
9835      && !(gsym != NULL && gsym->is_weak_undefined())
9836      && ((r_type == elfcpp::R_MIPS16_26 && !target_is_16_bit_code)
9837          || (r_type == elfcpp::R_MICROMIPS_26_S1 && !target_is_micromips_code)
9838          || ((r_type == elfcpp::R_MIPS_26 || r_type == elfcpp::R_MIPS_JALR)
9839              && (target_is_16_bit_code || target_is_micromips_code))));
9840
9841   bool local = (mips_sym == NULL
9842                 || (mips_sym->got_only_for_calls()
9843                     ? symbol_calls_local(mips_sym, mips_sym->has_dynsym_index())
9844                     : symbol_references_local(mips_sym,
9845                                               mips_sym->has_dynsym_index())));
9846
9847   // Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
9848   // to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
9849   // corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.
9850   if (got_page_reloc(r_type) && !local)
9851     r_type = (micromips_reloc(r_type) ? elfcpp::R_MICROMIPS_GOT_DISP
9852                                       : elfcpp::R_MIPS_GOT_DISP);
9853
9854   unsigned int got_offset = 0;
9855   int gp_offset = 0;
9856
9857   bool update_got_entry = false;
9858   bool extract_addend = rel_type == elfcpp::SHT_REL;
9859   switch (r_type)
9860     {
9861     case elfcpp::R_MIPS_NONE:
9862       break;
9863     case elfcpp::R_MIPS_16:
9864       reloc_status = Reloc_funcs::rel16(view, object, psymval, r_addend,
9865                                         extract_addend, r_type);
9866       break;
9867
9868     case elfcpp::R_MIPS_32:
9869       if (should_apply_r_mips_32_reloc(mips_sym, r_type, output_section,
9870                                        target))
9871         reloc_status = Reloc_funcs::rel32(view, object, psymval, r_addend,
9872                                           extract_addend, r_type);
9873       if (mips_sym != NULL
9874           && (mips_sym->is_mips16() || mips_sym->is_micromips())
9875           && mips_sym->global_got_area() == GGA_RELOC_ONLY)
9876         {
9877           // If mips_sym->has_mips16_fn_stub() is false, symbol value is
9878           // already updated by adding +1.
9879           if (mips_sym->has_mips16_fn_stub())
9880             {
9881               gold_assert(mips_sym->need_fn_stub());
9882               Mips16_stub_section<size, big_endian>* fn_stub =
9883                 mips_sym->template get_mips16_fn_stub<big_endian>();
9884
9885               symval.set_output_value(fn_stub->output_address());
9886               psymval = &symval;
9887             }
9888           got_offset = mips_sym->global_gotoffset();
9889           update_got_entry = true;
9890         }
9891       break;
9892
9893     case elfcpp::R_MIPS_REL32:
9894       gold_unreachable();
9895
9896     case elfcpp::R_MIPS_PC32:
9897       reloc_status = Reloc_funcs::relpc32(view, object, psymval, address,
9898                                           r_addend, extract_addend, r_type);
9899       break;
9900
9901     case elfcpp::R_MIPS16_26:
9902       // The calculation for R_MIPS16_26 is just the same as for an
9903       // R_MIPS_26.  It's only the storage of the relocated field into
9904       // the output file that's different.  So, we just fall through to the
9905       // R_MIPS_26 case here.
9906     case elfcpp::R_MIPS_26:
9907     case elfcpp::R_MICROMIPS_26_S1:
9908       reloc_status = Reloc_funcs::rel26(view, object, psymval, address,
9909           gsym == NULL, r_addend, extract_addend, gsym, cross_mode_jump, r_type,
9910           target->jal_to_bal());
9911       break;
9912
9913     case elfcpp::R_MIPS_HI16:
9914     case elfcpp::R_MIPS16_HI16:
9915     case elfcpp::R_MICROMIPS_HI16:
9916       reloc_status = Reloc_funcs::relhi16(view, object, psymval, r_addend,
9917                                           address, gp_disp, r_type, r_sym,
9918                                           extract_addend);
9919       break;
9920
9921     case elfcpp::R_MIPS_LO16:
9922     case elfcpp::R_MIPS16_LO16:
9923     case elfcpp::R_MICROMIPS_LO16:
9924     case elfcpp::R_MICROMIPS_HI0_LO16:
9925       reloc_status = Reloc_funcs::rello16(target, view, object, psymval,
9926                                           r_addend, extract_addend, address,
9927                                           gp_disp, r_type, r_sym);
9928       break;
9929
9930     case elfcpp::R_MIPS_LITERAL:
9931     case elfcpp::R_MICROMIPS_LITERAL:
9932       // Because we don't merge literal sections, we can handle this
9933       // just like R_MIPS_GPREL16.  In the long run, we should merge
9934       // shared literals, and then we will need to additional work
9935       // here.
9936
9937       // Fall through.
9938
9939     case elfcpp::R_MIPS_GPREL16:
9940     case elfcpp::R_MIPS16_GPREL:
9941     case elfcpp::R_MICROMIPS_GPREL7_S2:
9942     case elfcpp::R_MICROMIPS_GPREL16:
9943       reloc_status = Reloc_funcs::relgprel(view, object, psymval,
9944                                            target->adjusted_gp_value(object),
9945                                            r_addend, extract_addend,
9946                                            gsym == NULL, r_type);
9947       break;
9948
9949     case elfcpp::R_MIPS_PC16:
9950       reloc_status = Reloc_funcs::relpc16(view, object, psymval, address,
9951                                           r_addend, extract_addend, r_type);
9952       break;
9953     case elfcpp::R_MICROMIPS_PC7_S1:
9954       reloc_status = Reloc_funcs::relmicromips_pc7_s1(view, object, psymval,
9955                                                       address, r_addend,
9956                                                       extract_addend, r_type);
9957       break;
9958     case elfcpp::R_MICROMIPS_PC10_S1:
9959       reloc_status = Reloc_funcs::relmicromips_pc10_s1(view, object, psymval,
9960                                                        address, r_addend,
9961                                                        extract_addend, r_type);
9962       break;
9963     case elfcpp::R_MICROMIPS_PC16_S1:
9964       reloc_status = Reloc_funcs::relmicromips_pc16_s1(view, object, psymval,
9965                                                        address, r_addend,
9966                                                        extract_addend, r_type);
9967       break;
9968     case elfcpp::R_MIPS_GPREL32:
9969       reloc_status = Reloc_funcs::relgprel32(view, object, psymval,
9970                                              target->adjusted_gp_value(object),
9971                                              r_addend, extract_addend, r_type);
9972       break;
9973     case elfcpp::R_MIPS_GOT_HI16:
9974     case elfcpp::R_MIPS_CALL_HI16:
9975     case elfcpp::R_MICROMIPS_GOT_HI16:
9976     case elfcpp::R_MICROMIPS_CALL_HI16:
9977       if (gsym != NULL)
9978         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
9979                                                        object);
9980       else
9981         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
9982                                                        object);
9983       gp_offset = target->got_section()->gp_offset(got_offset, object);
9984       reloc_status = Reloc_funcs::relgot_hi16(view, gp_offset, r_type);
9985       update_got_entry = changed_symbol_value;
9986       break;
9987
9988     case elfcpp::R_MIPS_GOT_LO16:
9989     case elfcpp::R_MIPS_CALL_LO16:
9990     case elfcpp::R_MICROMIPS_GOT_LO16:
9991     case elfcpp::R_MICROMIPS_CALL_LO16:
9992       if (gsym != NULL)
9993         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
9994                                                        object);
9995       else
9996         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
9997                                                        object);
9998       gp_offset = target->got_section()->gp_offset(got_offset, object);
9999       reloc_status = Reloc_funcs::relgot_lo16(view, gp_offset, r_type);
10000       update_got_entry = changed_symbol_value;
10001       break;
10002
10003     case elfcpp::R_MIPS_GOT_DISP:
10004     case elfcpp::R_MICROMIPS_GOT_DISP:
10005       if (gsym != NULL)
10006         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
10007                                                        object);
10008       else
10009         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
10010                                                        object);
10011       gp_offset = target->got_section()->gp_offset(got_offset, object);
10012       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10013       break;
10014
10015     case elfcpp::R_MIPS_CALL16:
10016     case elfcpp::R_MIPS16_CALL16:
10017     case elfcpp::R_MICROMIPS_CALL16:
10018       gold_assert(gsym != NULL);
10019       got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
10020                                                      object);
10021       gp_offset = target->got_section()->gp_offset(got_offset, object);
10022       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10023       // TODO(sasa): We should also initialize update_got_entry in other places
10024       // where relgot is called.
10025       update_got_entry = changed_symbol_value;
10026       break;
10027
10028     case elfcpp::R_MIPS_GOT16:
10029     case elfcpp::R_MIPS16_GOT16:
10030     case elfcpp::R_MICROMIPS_GOT16:
10031       if (gsym != NULL)
10032         {
10033           got_offset = target->got_section()->got_offset(gsym,
10034                                                          GOT_TYPE_STANDARD,
10035                                                          object);
10036           gp_offset = target->got_section()->gp_offset(got_offset, object);
10037           reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10038         }
10039       else
10040         reloc_status = Reloc_funcs::relgot16_local(view, object, psymval,
10041                                                    r_addend, extract_addend,
10042                                                    r_type, r_sym);
10043       update_got_entry = changed_symbol_value;
10044       break;
10045
10046     case elfcpp::R_MIPS_TLS_GD:
10047     case elfcpp::R_MIPS16_TLS_GD:
10048     case elfcpp::R_MICROMIPS_TLS_GD:
10049       if (gsym != NULL)
10050         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_TLS_PAIR,
10051                                                        object);
10052       else
10053         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_TLS_PAIR,
10054                                                        object);
10055       gp_offset = target->got_section()->gp_offset(got_offset, object);
10056       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10057       break;
10058
10059     case elfcpp::R_MIPS_TLS_GOTTPREL:
10060     case elfcpp::R_MIPS16_TLS_GOTTPREL:
10061     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
10062       if (gsym != NULL)
10063         got_offset = target->got_section()->got_offset(gsym,
10064                                                        GOT_TYPE_TLS_OFFSET,
10065                                                        object);
10066       else
10067         got_offset = target->got_section()->got_offset(r_sym,
10068                                                        GOT_TYPE_TLS_OFFSET,
10069                                                        object);
10070       gp_offset = target->got_section()->gp_offset(got_offset, object);
10071       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10072       break;
10073
10074     case elfcpp::R_MIPS_TLS_LDM:
10075     case elfcpp::R_MIPS16_TLS_LDM:
10076     case elfcpp::R_MICROMIPS_TLS_LDM:
10077       // Relocate the field with the offset of the GOT entry for
10078       // the module index.
10079       got_offset = target->got_section()->tls_ldm_offset(object);
10080       gp_offset = target->got_section()->gp_offset(got_offset, object);
10081       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10082       break;
10083
10084     case elfcpp::R_MIPS_GOT_PAGE:
10085     case elfcpp::R_MICROMIPS_GOT_PAGE:
10086       reloc_status = Reloc_funcs::relgotpage(target, view, object, psymval,
10087                                              r_addend, extract_addend, r_type);
10088       break;
10089
10090     case elfcpp::R_MIPS_GOT_OFST:
10091     case elfcpp::R_MICROMIPS_GOT_OFST:
10092       reloc_status = Reloc_funcs::relgotofst(target, view, object, psymval,
10093                                              r_addend, extract_addend, local,
10094                                              r_type);
10095       break;
10096
10097     case elfcpp::R_MIPS_JALR:
10098     case elfcpp::R_MICROMIPS_JALR:
10099       // This relocation is only a hint.  In some cases, we optimize
10100       // it into a bal instruction.  But we don't try to optimize
10101       // when the symbol does not resolve locally.
10102       if (gsym == NULL || symbol_calls_local(gsym, gsym->has_dynsym_index()))
10103         reloc_status = Reloc_funcs::reljalr(view, object, psymval, address,
10104                                             r_addend, extract_addend,
10105                                             cross_mode_jump, r_type,
10106                                             target->jalr_to_bal(),
10107                                             target->jr_to_b());
10108       break;
10109
10110     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
10111     case elfcpp::R_MIPS16_TLS_DTPREL_HI16:
10112     case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16:
10113       reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval,
10114                                              elfcpp::DTP_OFFSET, r_addend,
10115                                              extract_addend, r_type);
10116       break;
10117     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
10118     case elfcpp::R_MIPS16_TLS_DTPREL_LO16:
10119     case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16:
10120       reloc_status = Reloc_funcs::tlsrello16(view, object, psymval,
10121                                              elfcpp::DTP_OFFSET, r_addend,
10122                                              extract_addend, r_type);
10123       break;
10124     case elfcpp::R_MIPS_TLS_DTPREL32:
10125     case elfcpp::R_MIPS_TLS_DTPREL64:
10126       reloc_status = Reloc_funcs::tlsrel32(view, object, psymval,
10127                                            elfcpp::DTP_OFFSET, r_addend,
10128                                            extract_addend, r_type);
10129       break;
10130     case elfcpp::R_MIPS_TLS_TPREL_HI16:
10131     case elfcpp::R_MIPS16_TLS_TPREL_HI16:
10132     case elfcpp::R_MICROMIPS_TLS_TPREL_HI16:
10133       reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval,
10134                                              elfcpp::TP_OFFSET, r_addend,
10135                                              extract_addend, r_type);
10136       break;
10137     case elfcpp::R_MIPS_TLS_TPREL_LO16:
10138     case elfcpp::R_MIPS16_TLS_TPREL_LO16:
10139     case elfcpp::R_MICROMIPS_TLS_TPREL_LO16:
10140       reloc_status = Reloc_funcs::tlsrello16(view, object, psymval,
10141                                              elfcpp::TP_OFFSET, r_addend,
10142                                              extract_addend, r_type);
10143       break;
10144     case elfcpp::R_MIPS_TLS_TPREL32:
10145     case elfcpp::R_MIPS_TLS_TPREL64:
10146       reloc_status = Reloc_funcs::tlsrel32(view, object, psymval,
10147                                            elfcpp::TP_OFFSET, r_addend,
10148                                            extract_addend, r_type);
10149       break;
10150     case elfcpp::R_MIPS_SUB:
10151     case elfcpp::R_MICROMIPS_SUB:
10152       reloc_status = Reloc_funcs::relsub(view, object, psymval, r_addend,
10153                                          extract_addend, r_type);
10154       break;
10155     default:
10156       gold_error_at_location(relinfo, relnum, r_offset,
10157                              _("unsupported reloc %u"), r_type);
10158       break;
10159     }
10160
10161   if (update_got_entry)
10162     {
10163       Mips_output_data_got<size, big_endian>* got = target->got_section();
10164       if (mips_sym != NULL && mips_sym->get_applied_secondary_got_fixup())
10165         got->update_got_entry(got->get_primary_got_offset(mips_sym),
10166                               psymval->value(object, 0));
10167       else
10168         got->update_got_entry(got_offset, psymval->value(object, 0));
10169     }
10170
10171   // Report any errors.
10172   switch (reloc_status)
10173     {
10174     case Reloc_funcs::STATUS_OKAY:
10175       break;
10176     case Reloc_funcs::STATUS_OVERFLOW:
10177       gold_error_at_location(relinfo, relnum, r_offset,
10178                              _("relocation overflow"));
10179       break;
10180     case Reloc_funcs::STATUS_BAD_RELOC:
10181       gold_error_at_location(relinfo, relnum, r_offset,
10182         _("unexpected opcode while processing relocation"));
10183       break;
10184     default:
10185       gold_unreachable();
10186     }
10187
10188   return true;
10189 }
10190
10191 template<int size, bool big_endian>
10192 inline bool
10193 Target_mips<size, big_endian>::Relocate::relocate(
10194                         const Relocate_info<size, big_endian>* relinfo,
10195                         Target_mips* target,
10196                         Output_section* output_section,
10197                         size_t relnum,
10198                         const elfcpp::Rela<size, big_endian>& reloc,
10199                         unsigned int r_type,
10200                         const Sized_symbol<size>* gsym,
10201                         const Symbol_value<size>* psymval,
10202                         unsigned char* view,
10203                         Mips_address address,
10204                         section_size_type view_size)
10205 {
10206   return relocate(
10207     relinfo,
10208     target,
10209     output_section,
10210     relnum,
10211     &reloc,
10212     (const elfcpp::Rel<size, big_endian>*) NULL,
10213     elfcpp::SHT_RELA,
10214     r_type,
10215     gsym,
10216     psymval,
10217     view,
10218     address,
10219     view_size);
10220 }
10221
10222 template<int size, bool big_endian>
10223 inline bool
10224 Target_mips<size, big_endian>::Relocate::relocate(
10225                         const Relocate_info<size, big_endian>* relinfo,
10226                         Target_mips* target,
10227                         Output_section* output_section,
10228                         size_t relnum,
10229                         const elfcpp::Rel<size, big_endian>& reloc,
10230                         unsigned int r_type,
10231                         const Sized_symbol<size>* gsym,
10232                         const Symbol_value<size>* psymval,
10233                         unsigned char* view,
10234                         Mips_address address,
10235                         section_size_type view_size)
10236 {
10237   return relocate(
10238     relinfo,
10239     target,
10240     output_section,
10241     relnum,
10242     (const elfcpp::Rela<size, big_endian>*) NULL,
10243     &reloc,
10244     elfcpp::SHT_REL,
10245     r_type,
10246     gsym,
10247     psymval,
10248     view,
10249     address,
10250     view_size);
10251 }
10252
10253 // Get the Reference_flags for a particular relocation.
10254
10255 template<int size, bool big_endian>
10256 int
10257 Target_mips<size, big_endian>::Scan::get_reference_flags(
10258                        unsigned int r_type)
10259 {
10260   switch (r_type)
10261     {
10262     case elfcpp::R_MIPS_NONE:
10263       // No symbol reference.
10264       return 0;
10265
10266     case elfcpp::R_MIPS_16:
10267     case elfcpp::R_MIPS_32:
10268     case elfcpp::R_MIPS_64:
10269     case elfcpp::R_MIPS_HI16:
10270     case elfcpp::R_MIPS_LO16:
10271     case elfcpp::R_MIPS16_HI16:
10272     case elfcpp::R_MIPS16_LO16:
10273     case elfcpp::R_MICROMIPS_HI16:
10274     case elfcpp::R_MICROMIPS_LO16:
10275       return Symbol::ABSOLUTE_REF;
10276
10277     case elfcpp::R_MIPS_26:
10278     case elfcpp::R_MIPS16_26:
10279     case elfcpp::R_MICROMIPS_26_S1:
10280       return Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF;
10281
10282     case elfcpp::R_MIPS_GPREL32:
10283     case elfcpp::R_MIPS_GPREL16:
10284     case elfcpp::R_MIPS_REL32:
10285     case elfcpp::R_MIPS16_GPREL:
10286       return Symbol::RELATIVE_REF;
10287
10288     case elfcpp::R_MIPS_PC16:
10289     case elfcpp::R_MIPS_PC32:
10290     case elfcpp::R_MIPS_JALR:
10291     case elfcpp::R_MICROMIPS_JALR:
10292       return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
10293
10294     case elfcpp::R_MIPS_GOT16:
10295     case elfcpp::R_MIPS_CALL16:
10296     case elfcpp::R_MIPS_GOT_DISP:
10297     case elfcpp::R_MIPS_GOT_HI16:
10298     case elfcpp::R_MIPS_GOT_LO16:
10299     case elfcpp::R_MIPS_CALL_HI16:
10300     case elfcpp::R_MIPS_CALL_LO16:
10301     case elfcpp::R_MIPS_LITERAL:
10302     case elfcpp::R_MIPS_GOT_PAGE:
10303     case elfcpp::R_MIPS_GOT_OFST:
10304     case elfcpp::R_MIPS16_GOT16:
10305     case elfcpp::R_MIPS16_CALL16:
10306     case elfcpp::R_MICROMIPS_GOT16:
10307     case elfcpp::R_MICROMIPS_CALL16:
10308     case elfcpp::R_MICROMIPS_GOT_HI16:
10309     case elfcpp::R_MICROMIPS_GOT_LO16:
10310     case elfcpp::R_MICROMIPS_CALL_HI16:
10311     case elfcpp::R_MICROMIPS_CALL_LO16:
10312       // Absolute in GOT.
10313       return Symbol::RELATIVE_REF;
10314
10315     case elfcpp::R_MIPS_TLS_DTPMOD32:
10316     case elfcpp::R_MIPS_TLS_DTPREL32:
10317     case elfcpp::R_MIPS_TLS_DTPMOD64:
10318     case elfcpp::R_MIPS_TLS_DTPREL64:
10319     case elfcpp::R_MIPS_TLS_GD:
10320     case elfcpp::R_MIPS_TLS_LDM:
10321     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
10322     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
10323     case elfcpp::R_MIPS_TLS_GOTTPREL:
10324     case elfcpp::R_MIPS_TLS_TPREL32:
10325     case elfcpp::R_MIPS_TLS_TPREL64:
10326     case elfcpp::R_MIPS_TLS_TPREL_HI16:
10327     case elfcpp::R_MIPS_TLS_TPREL_LO16:
10328     case elfcpp::R_MIPS16_TLS_GD:
10329     case elfcpp::R_MIPS16_TLS_GOTTPREL:
10330     case elfcpp::R_MICROMIPS_TLS_GD:
10331     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
10332     case elfcpp::R_MICROMIPS_TLS_TPREL_HI16:
10333     case elfcpp::R_MICROMIPS_TLS_TPREL_LO16:
10334       return Symbol::TLS_REF;
10335
10336     case elfcpp::R_MIPS_COPY:
10337     case elfcpp::R_MIPS_JUMP_SLOT:
10338     default:
10339       gold_unreachable();
10340       // Not expected.  We will give an error later.
10341       return 0;
10342     }
10343 }
10344
10345 // Report an unsupported relocation against a local symbol.
10346
10347 template<int size, bool big_endian>
10348 void
10349 Target_mips<size, big_endian>::Scan::unsupported_reloc_local(
10350                         Sized_relobj_file<size, big_endian>* object,
10351                         unsigned int r_type)
10352 {
10353   gold_error(_("%s: unsupported reloc %u against local symbol"),
10354              object->name().c_str(), r_type);
10355 }
10356
10357 // Report an unsupported relocation against a global symbol.
10358
10359 template<int size, bool big_endian>
10360 void
10361 Target_mips<size, big_endian>::Scan::unsupported_reloc_global(
10362                         Sized_relobj_file<size, big_endian>* object,
10363                         unsigned int r_type,
10364                         Symbol* gsym)
10365 {
10366   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
10367              object->name().c_str(), r_type, gsym->demangled_name().c_str());
10368 }
10369
10370 // Return printable name for ABI.
10371 template<int size, bool big_endian>
10372 const char*
10373 Target_mips<size, big_endian>::elf_mips_abi_name(elfcpp::Elf_Word e_flags,
10374                                                  unsigned char ei_class)
10375 {
10376   switch (e_flags & elfcpp::EF_MIPS_ABI)
10377     {
10378     case 0:
10379       if ((e_flags & elfcpp::EF_MIPS_ABI2) != 0)
10380         return "N32";
10381       else if (elfcpp::abi_64(ei_class))
10382         return "64";
10383       else
10384         return "none";
10385     case elfcpp::E_MIPS_ABI_O32:
10386       return "O32";
10387     case elfcpp::E_MIPS_ABI_O64:
10388       return "O64";
10389     case elfcpp::E_MIPS_ABI_EABI32:
10390       return "EABI32";
10391     case elfcpp::E_MIPS_ABI_EABI64:
10392       return "EABI64";
10393     default:
10394       return "unknown abi";
10395     }
10396 }
10397
10398 template<int size, bool big_endian>
10399 const char*
10400 Target_mips<size, big_endian>::elf_mips_mach_name(elfcpp::Elf_Word e_flags)
10401 {
10402   switch (e_flags & elfcpp::EF_MIPS_MACH)
10403     {
10404     case elfcpp::E_MIPS_MACH_3900:
10405       return "mips:3900";
10406     case elfcpp::E_MIPS_MACH_4010:
10407       return "mips:4010";
10408     case elfcpp::E_MIPS_MACH_4100:
10409       return "mips:4100";
10410     case elfcpp::E_MIPS_MACH_4111:
10411       return "mips:4111";
10412     case elfcpp::E_MIPS_MACH_4120:
10413       return "mips:4120";
10414     case elfcpp::E_MIPS_MACH_4650:
10415       return "mips:4650";
10416     case elfcpp::E_MIPS_MACH_5400:
10417       return "mips:5400";
10418     case elfcpp::E_MIPS_MACH_5500:
10419       return "mips:5500";
10420     case elfcpp::E_MIPS_MACH_SB1:
10421       return "mips:sb1";
10422     case elfcpp::E_MIPS_MACH_9000:
10423       return "mips:9000";
10424     case elfcpp::E_MIPS_MACH_LS2E:
10425       return "mips:loongson-2e";
10426     case elfcpp::E_MIPS_MACH_LS2F:
10427       return "mips:loongson-2f";
10428     case elfcpp::E_MIPS_MACH_LS3A:
10429       return "mips:loongson-3a";
10430     case elfcpp::E_MIPS_MACH_OCTEON:
10431       return "mips:octeon";
10432     case elfcpp::E_MIPS_MACH_OCTEON2:
10433       return "mips:octeon2";
10434     case elfcpp::E_MIPS_MACH_XLR:
10435       return "mips:xlr";
10436     default:
10437       switch (e_flags & elfcpp::EF_MIPS_ARCH)
10438         {
10439         default:
10440         case elfcpp::E_MIPS_ARCH_1:
10441           return "mips:3000";
10442
10443         case elfcpp::E_MIPS_ARCH_2:
10444           return "mips:6000";
10445
10446         case elfcpp::E_MIPS_ARCH_3:
10447           return "mips:4000";
10448
10449         case elfcpp::E_MIPS_ARCH_4:
10450           return "mips:8000";
10451
10452         case elfcpp::E_MIPS_ARCH_5:
10453           return "mips:mips5";
10454
10455         case elfcpp::E_MIPS_ARCH_32:
10456           return "mips:isa32";
10457
10458         case elfcpp::E_MIPS_ARCH_64:
10459           return "mips:isa64";
10460
10461         case elfcpp::E_MIPS_ARCH_32R2:
10462           return "mips:isa32r2";
10463
10464         case elfcpp::E_MIPS_ARCH_64R2:
10465           return "mips:isa64r2";
10466         }
10467     }
10468     return "unknown CPU";
10469 }
10470
10471 template<int size, bool big_endian>
10472 const Target::Target_info Target_mips<size, big_endian>::mips_info =
10473 {
10474   size,                 // size
10475   big_endian,           // is_big_endian
10476   elfcpp::EM_MIPS,      // machine_code
10477   true,                 // has_make_symbol
10478   false,                // has_resolve
10479   false,                // has_code_fill
10480   true,                 // is_default_stack_executable
10481   false,                // can_icf_inline_merge_sections
10482   '\0',                 // wrap_char
10483   "/lib/ld.so.1",       // dynamic_linker
10484   0x400000,             // default_text_segment_address
10485   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
10486   4 * 1024,             // common_pagesize (overridable by -z common-page-size)
10487   false,                // isolate_execinstr
10488   0,                    // rosegment_gap
10489   elfcpp::SHN_UNDEF,    // small_common_shndx
10490   elfcpp::SHN_UNDEF,    // large_common_shndx
10491   0,                    // small_common_section_flags
10492   0,                    // large_common_section_flags
10493   NULL,                 // attributes_section
10494   NULL,                 // attributes_vendor
10495   "__start",            // entry_symbol_name
10496   32,                   // hash_entry_size
10497 };
10498
10499 template<int size, bool big_endian>
10500 class Target_mips_nacl : public Target_mips<size, big_endian>
10501 {
10502  public:
10503   Target_mips_nacl()
10504     : Target_mips<size, big_endian>(&mips_nacl_info)
10505   { }
10506
10507  private:
10508   static const Target::Target_info mips_nacl_info;
10509 };
10510
10511 template<int size, bool big_endian>
10512 const Target::Target_info Target_mips_nacl<size, big_endian>::mips_nacl_info =
10513 {
10514   size,                 // size
10515   big_endian,           // is_big_endian
10516   elfcpp::EM_MIPS,      // machine_code
10517   true,                 // has_make_symbol
10518   false,                // has_resolve
10519   false,                // has_code_fill
10520   true,                 // is_default_stack_executable
10521   false,                // can_icf_inline_merge_sections
10522   '\0',                 // wrap_char
10523   "/lib/ld.so.1",       // dynamic_linker
10524   0x20000,              // default_text_segment_address
10525   0x10000,              // abi_pagesize (overridable by -z max-page-size)
10526   0x10000,              // common_pagesize (overridable by -z common-page-size)
10527   true,                 // isolate_execinstr
10528   0x10000000,           // rosegment_gap
10529   elfcpp::SHN_UNDEF,    // small_common_shndx
10530   elfcpp::SHN_UNDEF,    // large_common_shndx
10531   0,                    // small_common_section_flags
10532   0,                    // large_common_section_flags
10533   NULL,                 // attributes_section
10534   NULL,                 // attributes_vendor
10535   "_start",             // entry_symbol_name
10536   32,                   // hash_entry_size
10537 };
10538
10539 // Target selector for Mips.  Note this is never instantiated directly.
10540 // It's only used in Target_selector_mips_nacl, below.
10541
10542 template<int size, bool big_endian>
10543 class Target_selector_mips : public Target_selector
10544 {
10545 public:
10546   Target_selector_mips()
10547     : Target_selector(elfcpp::EM_MIPS, size, big_endian,
10548                 (size == 64 ?
10549                   (big_endian ? "elf64-tradbigmips" : "elf64-tradlittlemips") :
10550                   (big_endian ? "elf32-tradbigmips" : "elf32-tradlittlemips")),
10551                 (size == 64 ?
10552                   (big_endian ? "elf64-tradbigmips" : "elf64-tradlittlemips") :
10553                   (big_endian ? "elf32-tradbigmips" : "elf32-tradlittlemips")))
10554   { }
10555
10556   Target* do_instantiate_target()
10557   { return new Target_mips<size, big_endian>(); }
10558 };
10559
10560 template<int size, bool big_endian>
10561 class Target_selector_mips_nacl
10562   : public Target_selector_nacl<Target_selector_mips<size, big_endian>,
10563                                 Target_mips_nacl<size, big_endian> >
10564 {
10565  public:
10566   Target_selector_mips_nacl()
10567     : Target_selector_nacl<Target_selector_mips<size, big_endian>,
10568                            Target_mips_nacl<size, big_endian> >(
10569         // NaCl currently supports only MIPS32 little-endian.
10570         "mipsel", "elf32-tradlittlemips-nacl", "elf32-tradlittlemips-nacl")
10571   { }
10572 };
10573
10574 Target_selector_mips_nacl<32, true> target_selector_mips32;
10575 Target_selector_mips_nacl<32, false> target_selector_mips32el;
10576 Target_selector_mips_nacl<64, true> target_selector_mips64;
10577 Target_selector_mips_nacl<64, false> target_selector_mips64el;
10578
10579 } // End anonymous namespace.