Add NaCl (NativeClient) specific classes Target_mips_nacl and
[external/binutils.git] / gold / mips.cc
1 // mips.cc -- mips target support for gold.
2
3 // Copyright (C) 2011-2014 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     this->copy_relocs_.copy_reloc(symtab, layout,
3606                                   symtab->get_sized_symbol<size>(sym),
3607                                   object, shndx, output_section,
3608                                   reloc, this->rel_dyn_section(layout));
3609   }
3610
3611   void
3612   dynamic_reloc(Mips_symbol<size>* sym, unsigned int r_type,
3613                 Mips_relobj<size, big_endian>* relobj,
3614                 unsigned int shndx, Output_section* output_section,
3615                 Mips_address r_offset)
3616   {
3617     this->dyn_relocs_.push_back(Dyn_reloc(sym, r_type, relobj, shndx,
3618                                           output_section, r_offset));
3619   }
3620
3621   // Calculate value of _gp symbol.
3622   void
3623   set_gp(Layout*, Symbol_table*);
3624
3625   const char*
3626   elf_mips_abi_name(elfcpp::Elf_Word e_flags, unsigned char ei_class);
3627   const char*
3628   elf_mips_mach_name(elfcpp::Elf_Word e_flags);
3629
3630   // Adds entries that describe how machines relate to one another.  The entries
3631   // are ordered topologically with MIPS I extensions listed last.  First
3632   // element is extension, second element is base.
3633   void
3634   add_machine_extensions()
3635   {
3636     // MIPS64r2 extensions.
3637     this->add_extension(mach_mips_octeon2, mach_mips_octeonp);
3638     this->add_extension(mach_mips_octeonp, mach_mips_octeon);
3639     this->add_extension(mach_mips_octeon, mach_mipsisa64r2);
3640
3641     // MIPS64 extensions.
3642     this->add_extension(mach_mipsisa64r2, mach_mipsisa64);
3643     this->add_extension(mach_mips_sb1, mach_mipsisa64);
3644     this->add_extension(mach_mips_xlr, mach_mipsisa64);
3645     this->add_extension(mach_mips_loongson_3a, mach_mipsisa64);
3646
3647     // MIPS V extensions.
3648     this->add_extension(mach_mipsisa64, mach_mips5);
3649
3650     // R10000 extensions.
3651     this->add_extension(mach_mips12000, mach_mips10000);
3652     this->add_extension(mach_mips14000, mach_mips10000);
3653     this->add_extension(mach_mips16000, mach_mips10000);
3654
3655     // R5000 extensions.  Note: the vr5500 ISA is an extension of the core
3656     // vr5400 ISA, but doesn't include the multimedia stuff.  It seems
3657     // better to allow vr5400 and vr5500 code to be merged anyway, since
3658     // many libraries will just use the core ISA.  Perhaps we could add
3659     // some sort of ASE flag if this ever proves a problem.
3660     this->add_extension(mach_mips5500, mach_mips5400);
3661     this->add_extension(mach_mips5400, mach_mips5000);
3662
3663     // MIPS IV extensions.
3664     this->add_extension(mach_mips5, mach_mips8000);
3665     this->add_extension(mach_mips10000, mach_mips8000);
3666     this->add_extension(mach_mips5000, mach_mips8000);
3667     this->add_extension(mach_mips7000, mach_mips8000);
3668     this->add_extension(mach_mips9000, mach_mips8000);
3669
3670     // VR4100 extensions.
3671     this->add_extension(mach_mips4120, mach_mips4100);
3672     this->add_extension(mach_mips4111, mach_mips4100);
3673
3674     // MIPS III extensions.
3675     this->add_extension(mach_mips_loongson_2e, mach_mips4000);
3676     this->add_extension(mach_mips_loongson_2f, mach_mips4000);
3677     this->add_extension(mach_mips8000, mach_mips4000);
3678     this->add_extension(mach_mips4650, mach_mips4000);
3679     this->add_extension(mach_mips4600, mach_mips4000);
3680     this->add_extension(mach_mips4400, mach_mips4000);
3681     this->add_extension(mach_mips4300, mach_mips4000);
3682     this->add_extension(mach_mips4100, mach_mips4000);
3683     this->add_extension(mach_mips4010, mach_mips4000);
3684
3685     // MIPS32 extensions.
3686     this->add_extension(mach_mipsisa32r2, mach_mipsisa32);
3687
3688     // MIPS II extensions.
3689     this->add_extension(mach_mips4000, mach_mips6000);
3690     this->add_extension(mach_mipsisa32, mach_mips6000);
3691
3692     // MIPS I extensions.
3693     this->add_extension(mach_mips6000, mach_mips3000);
3694     this->add_extension(mach_mips3900, mach_mips3000);
3695   }
3696
3697   // Add value to MIPS extenstions.
3698   void
3699   add_extension(unsigned int base, unsigned int extension)
3700   {
3701     std::pair<unsigned int, unsigned int> ext(base, extension);
3702     this->mips_mach_extensions_.push_back(ext);
3703   }
3704
3705   // Return the number of entries in the .dynsym section.
3706   unsigned int get_dt_mips_symtabno() const
3707   {
3708     return ((unsigned int)(this->layout_->dynsym_section()->data_size()
3709                            / elfcpp::Elf_sizes<size>::sym_size));
3710     // TODO(sasa): Entry size is MIPS_ELF_SYM_SIZE.
3711   }
3712
3713   // Information about this specific target which we pass to the
3714   // general Target structure.
3715   static const Target::Target_info mips_info;
3716   // The GOT section.
3717   Mips_output_data_got<size, big_endian>* got_;
3718   // gp symbol.  It has the value of .got + 0x7FF0.
3719   Sized_symbol<size>* gp_;
3720   // The PLT section.
3721   Mips_output_data_plt<size, big_endian>* plt_;
3722   // The GOT PLT section.
3723   Output_data_space* got_plt_;
3724   // The dynamic reloc section.
3725   Reloc_section* rel_dyn_;
3726   // Relocs saved to avoid a COPY reloc.
3727   Mips_copy_relocs<elfcpp::SHT_REL, size, big_endian> copy_relocs_;
3728
3729   // A list of dyn relocs to be saved.
3730   std::vector<Dyn_reloc> dyn_relocs_;
3731
3732   // The LA25 stub section.
3733   Mips_output_data_la25_stub<size, big_endian>* la25_stub_;
3734   // Architecture extensions.
3735   std::vector<std::pair<unsigned int, unsigned int> > mips_mach_extensions_;
3736   // .MIPS.stubs
3737   Mips_output_data_mips_stubs<size, big_endian>* mips_stubs_;
3738
3739   unsigned char ei_class_;
3740   unsigned int mach_;
3741   Layout* layout_;
3742
3743   typename std::list<got16_addend<size, big_endian> > got16_addends_;
3744
3745   // Whether the entry symbol is mips16 or micromips.
3746   bool entry_symbol_is_compressed_;
3747
3748   // Whether we can use only 32-bit microMIPS instructions.
3749   // TODO(sasa): This should be a linker option.
3750   bool insn32_;
3751 };
3752
3753
3754 // Helper structure for R_MIPS*_HI16/LO16 and R_MIPS*_GOT16/LO16 relocations.
3755 // It records high part of the relocation pair.
3756
3757 template<int size, bool big_endian>
3758 struct reloc_high
3759 {
3760   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
3761
3762   reloc_high(unsigned char* _view, const Mips_relobj<size, big_endian>* _object,
3763              const Symbol_value<size>* _psymval, Mips_address _addend,
3764              unsigned int _r_type, bool _extract_addend,
3765              Mips_address _address = 0, bool _gp_disp = false)
3766     : view(_view), object(_object), psymval(_psymval), addend(_addend),
3767       r_type(_r_type), extract_addend(_extract_addend), address(_address),
3768       gp_disp(_gp_disp)
3769   { }
3770
3771   unsigned char* view;
3772   const Mips_relobj<size, big_endian>* object;
3773   const Symbol_value<size>* psymval;
3774   Mips_address addend;
3775   unsigned int r_type;
3776   bool extract_addend;
3777   Mips_address address;
3778   bool gp_disp;
3779 };
3780
3781 template<int size, bool big_endian>
3782 class Mips_relocate_functions : public Relocate_functions<size, big_endian>
3783 {
3784   typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address;
3785   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype16;
3786   typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32;
3787
3788  public:
3789   typedef enum
3790   {
3791     STATUS_OKAY,        // No error during relocation.
3792     STATUS_OVERFLOW,    // Relocation overflow.
3793     STATUS_BAD_RELOC    // Relocation cannot be applied.
3794   } Status;
3795
3796  private:
3797   typedef Relocate_functions<size, big_endian> Base;
3798   typedef Mips_relocate_functions<size, big_endian> This;
3799
3800   static typename std::list<reloc_high<size, big_endian> > hi16_relocs;
3801   static typename std::list<reloc_high<size, big_endian> > got16_relocs;
3802
3803   //   R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3804   //   Most mips16 instructions are 16 bits, but these instructions
3805   //   are 32 bits.
3806   //
3807   //   The format of these instructions is:
3808   //
3809   //   +--------------+--------------------------------+
3810   //   |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
3811   //   +--------------+--------------------------------+
3812   //   |                Immediate  15:0                |
3813   //   +-----------------------------------------------+
3814   //
3815   //   JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
3816   //   Note that the immediate value in the first word is swapped.
3817   //
3818   //   When producing a relocatable object file, R_MIPS16_26 is
3819   //   handled mostly like R_MIPS_26.  In particular, the addend is
3820   //   stored as a straight 26-bit value in a 32-bit instruction.
3821   //   (gas makes life simpler for itself by never adjusting a
3822   //   R_MIPS16_26 reloc to be against a section, so the addend is
3823   //   always zero).  However, the 32 bit instruction is stored as 2
3824   //   16-bit values, rather than a single 32-bit value.  In a
3825   //   big-endian file, the result is the same; in a little-endian
3826   //   file, the two 16-bit halves of the 32 bit value are swapped.
3827   //   This is so that a disassembler can recognize the jal
3828   //   instruction.
3829   //
3830   //   When doing a final link, R_MIPS16_26 is treated as a 32 bit
3831   //   instruction stored as two 16-bit values.  The addend A is the
3832   //   contents of the targ26 field.  The calculation is the same as
3833   //   R_MIPS_26.  When storing the calculated value, reorder the
3834   //   immediate value as shown above, and don't forget to store the
3835   //   value as two 16-bit values.
3836   //
3837   //   To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3838   //   defined as
3839   //
3840   //   big-endian:
3841   //   +--------+----------------------+
3842   //   |        |                      |
3843   //   |        |    targ26-16         |
3844   //   |31    26|25                   0|
3845   //   +--------+----------------------+
3846   //
3847   //   little-endian:
3848   //   +----------+------+-------------+
3849   //   |          |      |             |
3850   //   |  sub1    |      |     sub2    |
3851   //   |0        9|10  15|16         31|
3852   //   +----------+--------------------+
3853   //   where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3854   //   ((sub1 << 16) | sub2)).
3855   //
3856   //   When producing a relocatable object file, the calculation is
3857   //   (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3858   //   When producing a fully linked file, the calculation is
3859   //   let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3860   //   ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
3861   //
3862   //   The table below lists the other MIPS16 instruction relocations.
3863   //   Each one is calculated in the same way as the non-MIPS16 relocation
3864   //   given on the right, but using the extended MIPS16 layout of 16-bit
3865   //   immediate fields:
3866   //
3867   //      R_MIPS16_GPREL          R_MIPS_GPREL16
3868   //      R_MIPS16_GOT16          R_MIPS_GOT16
3869   //      R_MIPS16_CALL16         R_MIPS_CALL16
3870   //      R_MIPS16_HI16           R_MIPS_HI16
3871   //      R_MIPS16_LO16           R_MIPS_LO16
3872   //
3873   //   A typical instruction will have a format like this:
3874   //
3875   //   +--------------+--------------------------------+
3876   //   |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
3877   //   +--------------+--------------------------------+
3878   //   |    Major     |   rx   |   ry   |   Imm  4:0   |
3879   //   +--------------+--------------------------------+
3880   //
3881   //   EXTEND is the five bit value 11110.  Major is the instruction
3882   //   opcode.
3883   //
3884   //   All we need to do here is shuffle the bits appropriately.
3885   //   As above, the two 16-bit halves must be swapped on a
3886   //   little-endian system.
3887
3888   // Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
3889   // on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
3890   // and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.
3891
3892   static inline bool
3893   should_shuffle_micromips_reloc(unsigned int r_type)
3894   {
3895     return (micromips_reloc(r_type)
3896             && r_type != elfcpp::R_MICROMIPS_PC7_S1
3897             && r_type != elfcpp::R_MICROMIPS_PC10_S1);
3898   }
3899
3900   static void
3901   mips_reloc_unshuffle(unsigned char* view, unsigned int r_type,
3902                        bool jal_shuffle)
3903   {
3904     if (!mips16_reloc(r_type)
3905         && !should_shuffle_micromips_reloc(r_type))
3906       return;
3907
3908     // Pick up the first and second halfwords of the instruction.
3909     Valtype16 first = elfcpp::Swap<16, big_endian>::readval(view);
3910     Valtype16 second = elfcpp::Swap<16, big_endian>::readval(view + 2);
3911     Valtype32 val;
3912
3913     if (micromips_reloc(r_type)
3914         || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle))
3915       val = first << 16 | second;
3916     else if (r_type != elfcpp::R_MIPS16_26)
3917       val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
3918              | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
3919     else
3920       val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
3921              | ((first & 0x1f) << 21) | second);
3922
3923     elfcpp::Swap<32, big_endian>::writeval(view, val);
3924   }
3925
3926   static void
3927   mips_reloc_shuffle(unsigned char* view, unsigned int r_type, bool jal_shuffle)
3928   {
3929     if (!mips16_reloc(r_type)
3930         && !should_shuffle_micromips_reloc(r_type))
3931       return;
3932
3933     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
3934     Valtype16 first, second;
3935
3936     if (micromips_reloc(r_type)
3937         || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle))
3938       {
3939         second = val & 0xffff;
3940         first = val >> 16;
3941       }
3942     else if (r_type != elfcpp::R_MIPS16_26)
3943       {
3944         second = ((val >> 11) & 0xffe0) | (val & 0x1f);
3945         first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
3946       }
3947     else
3948       {
3949         second = val & 0xffff;
3950         first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
3951                  | ((val >> 21) & 0x1f);
3952       }
3953
3954     elfcpp::Swap<16, big_endian>::writeval(view + 2, second);
3955     elfcpp::Swap<16, big_endian>::writeval(view, first);
3956   }
3957
3958  public:
3959   // R_MIPS_16: S + sign-extend(A)
3960   static inline typename This::Status
3961   rel16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
3962         const Symbol_value<size>* psymval, Mips_address addend_a,
3963         bool extract_addend, unsigned int r_type)
3964   {
3965     mips_reloc_unshuffle(view, r_type, false);
3966     Valtype16* wv = reinterpret_cast<Valtype16*>(view);
3967     Valtype16 val = elfcpp::Swap<16, big_endian>::readval(wv);
3968
3969     Valtype32 addend = (extract_addend ? Bits<16>::sign_extend32(val)
3970                                        : Bits<16>::sign_extend32(addend_a));
3971
3972     Valtype32 x = psymval->value(object, addend);
3973     val = Bits<16>::bit_select32(val, x, 0xffffU);
3974     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3975     mips_reloc_shuffle(view, r_type, false);
3976     return (Bits<16>::has_overflow32(x)
3977             ? This::STATUS_OVERFLOW
3978             : This::STATUS_OKAY);
3979   }
3980
3981   // R_MIPS_32: S + A
3982   static inline typename This::Status
3983   rel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
3984         const Symbol_value<size>* psymval, Mips_address addend_a,
3985         bool extract_addend, unsigned int r_type)
3986   {
3987     mips_reloc_unshuffle(view, r_type, false);
3988     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
3989     Valtype32 addend = (extract_addend
3990                         ? elfcpp::Swap<32, big_endian>::readval(wv)
3991                         : Bits<32>::sign_extend32(addend_a));
3992     Valtype32 x = psymval->value(object, addend);
3993     elfcpp::Swap<32, big_endian>::writeval(wv, x);
3994     mips_reloc_shuffle(view, r_type, false);
3995     return This::STATUS_OKAY;
3996   }
3997
3998   // R_MIPS_JALR, R_MICROMIPS_JALR
3999   static inline typename This::Status
4000   reljalr(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4001           const Symbol_value<size>* psymval, Mips_address address,
4002           Mips_address addend_a, bool extract_addend, bool cross_mode_jump,
4003           unsigned int r_type, bool jalr_to_bal, bool jr_to_b)
4004   {
4005     mips_reloc_unshuffle(view, r_type, false);
4006     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4007     Valtype32 addend = extract_addend ? 0 : addend_a;
4008     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4009
4010     // Try converting J(AL)R to B(AL), if the target is in range.
4011     if (!parameters->options().relocatable()
4012         && r_type == elfcpp::R_MIPS_JALR
4013         && !cross_mode_jump
4014         && ((jalr_to_bal && val == 0x0320f809)    // jalr t9
4015             || (jr_to_b && val == 0x03200008)))   // jr t9
4016       {
4017         int offset = psymval->value(object, addend) - (address + 4);
4018         if (!Bits<18>::has_overflow32(offset))
4019           {
4020             if (val == 0x03200008)   // jr t9
4021               val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff);  // b addr
4022             else
4023               val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr
4024           }
4025       }
4026
4027     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4028     mips_reloc_shuffle(view, r_type, false);
4029     return This::STATUS_OKAY;
4030   }
4031
4032   // R_MIPS_PC32: S + A - P
4033   static inline typename This::Status
4034   relpc32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4035           const Symbol_value<size>* psymval, Mips_address address,
4036           Mips_address addend_a, bool extract_addend, unsigned int r_type)
4037   {
4038     mips_reloc_unshuffle(view, r_type, false);
4039     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4040     Valtype32 addend = (extract_addend
4041                         ? elfcpp::Swap<32, big_endian>::readval(wv)
4042                         : Bits<32>::sign_extend32(addend_a));
4043     Valtype32 x = psymval->value(object, addend) - address;
4044     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4045     mips_reloc_shuffle(view, r_type, false);
4046     return This::STATUS_OKAY;
4047   }
4048
4049   // R_MIPS_26, R_MIPS16_26, R_MICROMIPS_26_S1
4050   static inline typename This::Status
4051   rel26(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4052         const Symbol_value<size>* psymval, Mips_address address,
4053         bool local, Mips_address addend_a, bool extract_addend,
4054         const Symbol* gsym, bool cross_mode_jump, unsigned int r_type,
4055         bool jal_to_bal)
4056   {
4057     mips_reloc_unshuffle(view, r_type, false);
4058     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4059     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4060
4061     Valtype32 addend;
4062     if (extract_addend)
4063       {
4064         if (r_type == elfcpp::R_MICROMIPS_26_S1)
4065           addend = (val & 0x03ffffff) << 1;
4066         else
4067           addend = (val & 0x03ffffff) << 2;
4068       }
4069     else
4070       addend = addend_a;
4071
4072     // Make sure the target of JALX is word-aligned.  Bit 0 must be
4073     // the correct ISA mode selector and bit 1 must be 0.
4074     if (cross_mode_jump
4075         && (psymval->value(object, 0) & 3) != (r_type == elfcpp::R_MIPS_26))
4076       {
4077         gold_warning(_("JALX to a non-word-aligned address"));
4078         mips_reloc_shuffle(view, r_type, !parameters->options().relocatable());
4079         return This::STATUS_BAD_RELOC;
4080       }
4081
4082     // Shift is 2, unusually, for microMIPS JALX.
4083     unsigned int shift =
4084         (!cross_mode_jump && r_type == elfcpp::R_MICROMIPS_26_S1) ? 1 : 2;
4085
4086     Valtype32 x;
4087     if (local)
4088       x = addend | ((address + 4) & (0xfc000000 << shift));
4089     else
4090       {
4091         if (shift == 1)
4092           x = Bits<27>::sign_extend32(addend);
4093         else
4094           x = Bits<28>::sign_extend32(addend);
4095       }
4096     x = psymval->value(object, x) >> shift;
4097
4098     if (!local && !gsym->is_weak_undefined())
4099       {
4100         if ((x >> 26) != ((address + 4) >> (26 + shift)))
4101           {
4102             gold_error(_("relocation truncated to fit: %u against '%s'"),
4103                        r_type, gsym->name());
4104             return This::STATUS_OVERFLOW;
4105           }
4106       }
4107
4108     val = Bits<32>::bit_select32(val, x, 0x03ffffff);
4109
4110     // If required, turn JAL into JALX.
4111     if (cross_mode_jump)
4112       {
4113         bool ok;
4114         Valtype32 opcode = val >> 26;
4115         Valtype32 jalx_opcode;
4116
4117         // Check to see if the opcode is already JAL or JALX.
4118         if (r_type == elfcpp::R_MIPS16_26)
4119           {
4120             ok = (opcode == 0x6) || (opcode == 0x7);
4121             jalx_opcode = 0x7;
4122           }
4123         else if (r_type == elfcpp::R_MICROMIPS_26_S1)
4124           {
4125             ok = (opcode == 0x3d) || (opcode == 0x3c);
4126             jalx_opcode = 0x3c;
4127           }
4128         else
4129           {
4130             ok = (opcode == 0x3) || (opcode == 0x1d);
4131             jalx_opcode = 0x1d;
4132           }
4133
4134         // If the opcode is not JAL or JALX, there's a problem.  We cannot
4135         // convert J or JALS to JALX.
4136         if (!ok)
4137           {
4138             gold_error(_("Unsupported jump between ISA modes; consider "
4139                          "recompiling with interlinking enabled."));
4140             return This::STATUS_BAD_RELOC;
4141           }
4142
4143         // Make this the JALX opcode.
4144         val = (val & ~(0x3f << 26)) | (jalx_opcode << 26);
4145       }
4146
4147     // Try converting JAL to BAL, if the target is in range.
4148     if (!parameters->options().relocatable()
4149         && !cross_mode_jump
4150         && ((jal_to_bal
4151             && r_type == elfcpp::R_MIPS_26
4152             && (val >> 26) == 0x3)))    // jal addr
4153       {
4154         Valtype32 dest = (x << 2) | (((address + 4) >> 28) << 28);
4155         int offset = dest - (address + 4);
4156         if (!Bits<18>::has_overflow32(offset))
4157           {
4158             if (val == 0x03200008)   // jr t9
4159               val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff);  // b addr
4160             else
4161               val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr
4162           }
4163       }
4164
4165     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4166     mips_reloc_shuffle(view, r_type, !parameters->options().relocatable());
4167     return This::STATUS_OKAY;
4168   }
4169
4170   // R_MIPS_PC16
4171   static inline typename This::Status
4172   relpc16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4173           const Symbol_value<size>* psymval, Mips_address address,
4174           Mips_address addend_a, bool extract_addend, unsigned int r_type)
4175   {
4176     mips_reloc_unshuffle(view, r_type, false);
4177     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4178     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4179
4180     Valtype32 addend = extract_addend ? (val & 0xffff) << 2 : addend_a;
4181     addend = Bits<18>::sign_extend32(addend);
4182
4183     Valtype32 x = psymval->value(object, addend) - address;
4184     val = Bits<16>::bit_select32(val, x >> 2, 0xffff);
4185     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4186     mips_reloc_shuffle(view, r_type, false);
4187     return (Bits<18>::has_overflow32(x)
4188             ? This::STATUS_OVERFLOW
4189             : This::STATUS_OKAY);
4190   }
4191
4192   // R_MICROMIPS_PC7_S1
4193   static inline typename This::Status
4194   relmicromips_pc7_s1(unsigned char* view,
4195                       const Mips_relobj<size, big_endian>* object,
4196                       const Symbol_value<size>* psymval, Mips_address address,
4197                       Mips_address addend_a, bool extract_addend,
4198                       unsigned int r_type)
4199   {
4200     mips_reloc_unshuffle(view, r_type, false);
4201     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4202     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4203
4204     Valtype32 addend = extract_addend ? (val & 0x7f) << 1 : addend_a;
4205     addend = Bits<8>::sign_extend32(addend);
4206
4207     Valtype32 x = psymval->value(object, addend) - address;
4208     val = Bits<16>::bit_select32(val, x >> 1, 0x7f);
4209     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4210     mips_reloc_shuffle(view, r_type, false);
4211     return (Bits<8>::has_overflow32(x)
4212             ? This::STATUS_OVERFLOW
4213             : This::STATUS_OKAY);
4214   }
4215
4216   // R_MICROMIPS_PC10_S1
4217   static inline typename This::Status
4218   relmicromips_pc10_s1(unsigned char* view,
4219                        const Mips_relobj<size, big_endian>* object,
4220                        const Symbol_value<size>* psymval, Mips_address address,
4221                        Mips_address addend_a, bool extract_addend,
4222                        unsigned int r_type)
4223   {
4224     mips_reloc_unshuffle(view, r_type, false);
4225     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4226     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4227
4228     Valtype32 addend = extract_addend ? (val & 0x3ff) << 1 : addend_a;
4229     addend = Bits<11>::sign_extend32(addend);
4230
4231     Valtype32 x = psymval->value(object, addend) - address;
4232     val = Bits<16>::bit_select32(val, x >> 1, 0x3ff);
4233     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4234     mips_reloc_shuffle(view, r_type, false);
4235     return (Bits<11>::has_overflow32(x)
4236             ? This::STATUS_OVERFLOW
4237             : This::STATUS_OKAY);
4238   }
4239
4240   // R_MICROMIPS_PC16_S1
4241   static inline typename This::Status
4242   relmicromips_pc16_s1(unsigned char* view,
4243                        const Mips_relobj<size, big_endian>* object,
4244                        const Symbol_value<size>* psymval, Mips_address address,
4245                        Mips_address addend_a, bool extract_addend,
4246                        unsigned int r_type)
4247   {
4248     mips_reloc_unshuffle(view, r_type, false);
4249     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4250     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4251
4252     Valtype32 addend = extract_addend ? (val & 0xffff) << 1 : addend_a;
4253     addend = Bits<17>::sign_extend32(addend);
4254
4255     Valtype32 x = psymval->value(object, addend) - address;
4256     val = Bits<16>::bit_select32(val, x >> 1, 0xffff);
4257     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4258     mips_reloc_shuffle(view, r_type, false);
4259     return (Bits<17>::has_overflow32(x)
4260             ? This::STATUS_OVERFLOW
4261             : This::STATUS_OKAY);
4262   }
4263
4264   // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
4265   static inline typename This::Status
4266   relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4267           const Symbol_value<size>* psymval, Mips_address addend,
4268           Mips_address address, bool gp_disp, unsigned int r_type,
4269           bool extract_addend)
4270   {
4271     // Record the relocation.  It will be resolved when we find lo16 part.
4272     hi16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval,
4273                           addend, r_type, extract_addend, address, gp_disp));
4274     return This::STATUS_OKAY;
4275   }
4276
4277   // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
4278   static inline typename This::Status
4279   do_relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4280              const Symbol_value<size>* psymval, Mips_address addend_hi,
4281              Mips_address address, bool is_gp_disp, unsigned int r_type,
4282              bool extract_addend, Valtype32 addend_lo,
4283              Target_mips<size, big_endian>* target)
4284   {
4285     mips_reloc_unshuffle(view, r_type, false);
4286     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4287     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4288
4289     Valtype32 addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo
4290                                        : addend_hi);
4291
4292     Valtype32 value;
4293     if (!is_gp_disp)
4294       value = psymval->value(object, addend);
4295     else
4296       {
4297         // For MIPS16 ABI code we generate this sequence
4298         //    0: li      $v0,%hi(_gp_disp)
4299         //    4: addiupc $v1,%lo(_gp_disp)
4300         //    8: sll     $v0,16
4301         //   12: addu    $v0,$v1
4302         //   14: move    $gp,$v0
4303         // So the offsets of hi and lo relocs are the same, but the
4304         // base $pc is that used by the ADDIUPC instruction at $t9 + 4.
4305         // ADDIUPC clears the low two bits of the instruction address,
4306         // so the base is ($t9 + 4) & ~3.
4307         Valtype32 gp_disp;
4308         if (r_type == elfcpp::R_MIPS16_HI16)
4309           gp_disp = (target->adjusted_gp_value(object)
4310                      - ((address + 4) & ~0x3));
4311         // The microMIPS .cpload sequence uses the same assembly
4312         // instructions as the traditional psABI version, but the
4313         // incoming $t9 has the low bit set.
4314         else if (r_type == elfcpp::R_MICROMIPS_HI16)
4315           gp_disp = target->adjusted_gp_value(object) - address - 1;
4316         else
4317           gp_disp = target->adjusted_gp_value(object) - address;
4318         value = gp_disp + addend;
4319       }
4320     Valtype32 x = ((value + 0x8000) >> 16) & 0xffff;
4321     val = Bits<32>::bit_select32(val, x, 0xffff);
4322     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4323     mips_reloc_shuffle(view, r_type, false);
4324     return (is_gp_disp && Bits<16>::has_overflow32(x)
4325             ? This::STATUS_OVERFLOW
4326             : This::STATUS_OKAY);
4327   }
4328
4329   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4330   static inline typename This::Status
4331   relgot16_local(unsigned char* view,
4332                  const Mips_relobj<size, big_endian>* object,
4333                  const Symbol_value<size>* psymval, Mips_address addend_a,
4334                  bool extract_addend, unsigned int r_type)
4335   {
4336     // Record the relocation.  It will be resolved when we find lo16 part.
4337     got16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval,
4338                            addend_a, r_type, extract_addend));
4339     return This::STATUS_OKAY;
4340   }
4341
4342   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4343   static inline typename This::Status
4344   do_relgot16_local(unsigned char* view,
4345                     const Mips_relobj<size, big_endian>* object,
4346                     const Symbol_value<size>* psymval, Mips_address addend_hi,
4347                     unsigned int r_type, bool extract_addend,
4348                     Valtype32 addend_lo, Target_mips<size, big_endian>* target)
4349   {
4350     mips_reloc_unshuffle(view, r_type, false);
4351     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4352     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4353
4354     Valtype32 addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo
4355                                        : addend_hi);
4356
4357     // Find GOT page entry.
4358     Mips_address value = ((psymval->value(object, addend) + 0x8000) >> 16)
4359                           & 0xffff;
4360     value <<= 16;
4361     unsigned int got_offset =
4362       target->got_section()->get_got_page_offset(value, object);
4363
4364     // Resolve the relocation.
4365     Valtype32 x = target->got_section()->gp_offset(got_offset, object);
4366     val = Bits<32>::bit_select32(val, x, 0xffff);
4367     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4368     mips_reloc_shuffle(view, r_type, false);
4369     return (Bits<16>::has_overflow32(x)
4370             ? This::STATUS_OVERFLOW
4371             : This::STATUS_OKAY);
4372   }
4373
4374   // R_MIPS_LO16, R_MIPS16_LO16, R_MICROMIPS_LO16, R_MICROMIPS_HI0_LO16
4375   static inline typename This::Status
4376   rello16(Target_mips<size, big_endian>* target, unsigned char* view,
4377           const Mips_relobj<size, big_endian>* object,
4378           const Symbol_value<size>* psymval, Mips_address addend_a,
4379           bool extract_addend, Mips_address address, bool is_gp_disp,
4380           unsigned int r_type)
4381   {
4382     mips_reloc_unshuffle(view, r_type, false);
4383     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4384     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4385
4386     Valtype32 addend = (extract_addend ? Bits<16>::sign_extend32(val & 0xffff)
4387                                        : addend_a);
4388
4389     // Resolve pending R_MIPS_HI16 relocations.
4390     typename std::list<reloc_high<size, big_endian> >::iterator it =
4391       hi16_relocs.begin();
4392     while (it != hi16_relocs.end())
4393       {
4394         reloc_high<size, big_endian> hi16 = *it;
4395         if (hi16.psymval->value(hi16.object, 0) == psymval->value(object, 0))
4396           {
4397             if (do_relhi16(hi16.view, hi16.object, hi16.psymval, hi16.addend,
4398                            hi16.address, hi16.gp_disp, hi16.r_type,
4399                            hi16.extract_addend, addend, target)
4400                 == This::STATUS_OVERFLOW)
4401               return This::STATUS_OVERFLOW;
4402             it = hi16_relocs.erase(it);
4403           }
4404         else
4405           ++it;
4406       }
4407
4408     // Resolve pending local R_MIPS_GOT16 relocations.
4409     typename std::list<reloc_high<size, big_endian> >::iterator it2 =
4410       got16_relocs.begin();
4411     while (it2 != got16_relocs.end())
4412       {
4413         reloc_high<size, big_endian> got16 = *it2;
4414         if (got16.psymval->value(got16.object, 0) == psymval->value(object, 0))
4415           {
4416             if (do_relgot16_local(got16.view, got16.object, got16.psymval,
4417                                   got16.addend, got16.r_type,
4418                                   got16.extract_addend, addend,
4419                                   target) == This::STATUS_OVERFLOW)
4420               return This::STATUS_OVERFLOW;
4421             it2 = got16_relocs.erase(it2);
4422           }
4423         else
4424           ++it2;
4425       }
4426
4427     // Resolve R_MIPS_LO16 relocation.
4428     Valtype32 x;
4429     if (!is_gp_disp)
4430       x = psymval->value(object, addend);
4431     else
4432       {
4433         // See the comment for R_MIPS16_HI16 above for the reason
4434         // for this conditional.
4435         Valtype32 gp_disp;
4436         if (r_type == elfcpp::R_MIPS16_LO16)
4437           gp_disp = target->adjusted_gp_value(object) - (address & ~0x3);
4438         else if (r_type == elfcpp::R_MICROMIPS_LO16
4439                  || r_type == elfcpp::R_MICROMIPS_HI0_LO16)
4440           gp_disp = target->adjusted_gp_value(object) - address + 3;
4441         else
4442           gp_disp = target->adjusted_gp_value(object) - address + 4;
4443         // The MIPS ABI requires checking the R_MIPS_LO16 relocation
4444         // for overflow.  Relocations against _gp_disp are normally
4445         // generated from the .cpload pseudo-op.  It generates code
4446         // that normally looks like this:
4447
4448         //   lui    $gp,%hi(_gp_disp)
4449         //   addiu  $gp,$gp,%lo(_gp_disp)
4450         //   addu   $gp,$gp,$t9
4451
4452         // Here $t9 holds the address of the function being called,
4453         // as required by the MIPS ELF ABI.  The R_MIPS_LO16
4454         // relocation can easily overflow in this situation, but the
4455         // R_MIPS_HI16 relocation will handle the overflow.
4456         // Therefore, we consider this a bug in the MIPS ABI, and do
4457         // not check for overflow here.
4458         x = gp_disp + addend;
4459       }
4460     val = Bits<32>::bit_select32(val, x, 0xffff);
4461     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4462     mips_reloc_shuffle(view, r_type, false);
4463     return This::STATUS_OKAY;
4464   }
4465
4466   // R_MIPS_CALL16, R_MIPS16_CALL16, R_MICROMIPS_CALL16
4467   // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
4468   // R_MIPS_TLS_GD, R_MIPS16_TLS_GD, R_MICROMIPS_TLS_GD
4469   // R_MIPS_TLS_GOTTPREL, R_MIPS16_TLS_GOTTPREL, R_MICROMIPS_TLS_GOTTPREL
4470   // R_MIPS_TLS_LDM, R_MIPS16_TLS_LDM, R_MICROMIPS_TLS_LDM
4471   // R_MIPS_GOT_DISP, R_MICROMIPS_GOT_DISP
4472   static inline typename This::Status
4473   relgot(unsigned char* view, int gp_offset, unsigned int r_type)
4474   {
4475     mips_reloc_unshuffle(view, r_type, false);
4476     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4477     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4478     Valtype32 x = gp_offset;
4479     val = Bits<32>::bit_select32(val, x, 0xffff);
4480     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4481     mips_reloc_shuffle(view, r_type, false);
4482     return (Bits<16>::has_overflow32(x)
4483             ? This::STATUS_OVERFLOW
4484             : This::STATUS_OKAY);
4485   }
4486
4487   // R_MIPS_GOT_PAGE, R_MICROMIPS_GOT_PAGE
4488   static inline typename This::Status
4489   relgotpage(Target_mips<size, big_endian>* target, unsigned char* view,
4490              const Mips_relobj<size, big_endian>* object,
4491              const Symbol_value<size>* psymval, Mips_address addend_a,
4492              bool extract_addend, unsigned int r_type)
4493   {
4494     mips_reloc_unshuffle(view, r_type, false);
4495     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4496     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
4497     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4498
4499     // Find a GOT page entry that points to within 32KB of symbol + addend.
4500     Mips_address value = (psymval->value(object, addend) + 0x8000) & ~0xffff;
4501     unsigned int  got_offset =
4502       target->got_section()->get_got_page_offset(value, object);
4503
4504     Valtype32 x = target->got_section()->gp_offset(got_offset, object);
4505     val = Bits<32>::bit_select32(val, x, 0xffff);
4506     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4507     mips_reloc_shuffle(view, r_type, false);
4508     return (Bits<16>::has_overflow32(x)
4509             ? This::STATUS_OVERFLOW
4510             : This::STATUS_OKAY);
4511   }
4512
4513   // R_MIPS_GOT_OFST, R_MICROMIPS_GOT_OFST
4514   static inline typename This::Status
4515   relgotofst(Target_mips<size, big_endian>* target, unsigned char* view,
4516              const Mips_relobj<size, big_endian>* object,
4517              const Symbol_value<size>* psymval, Mips_address addend_a,
4518              bool extract_addend, bool local, unsigned int r_type)
4519   {
4520     mips_reloc_unshuffle(view, r_type, false);
4521     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4522     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
4523     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4524
4525     // For a local symbol, find a GOT page entry that points to within 32KB of
4526     // symbol + addend.  Relocation value is the offset of the GOT page entry's
4527     // value from symbol + addend.
4528     // For a global symbol, relocation value is addend.
4529     Valtype32 x;
4530     if (local)
4531       {
4532         // Find GOT page entry.
4533         Mips_address value = ((psymval->value(object, addend) + 0x8000)
4534                               & ~0xffff);
4535         target->got_section()->get_got_page_offset(value, object);
4536
4537         x = psymval->value(object, addend) - value;
4538       }
4539     else
4540       x = addend;
4541     val = Bits<32>::bit_select32(val, x, 0xffff);
4542     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4543     mips_reloc_shuffle(view, r_type, false);
4544     return (Bits<16>::has_overflow32(x)
4545             ? This::STATUS_OVERFLOW
4546             : This::STATUS_OKAY);
4547   }
4548
4549   // R_MIPS_GOT_HI16, R_MIPS_CALL_HI16,
4550   // R_MICROMIPS_GOT_HI16, R_MICROMIPS_CALL_HI16
4551   static inline typename This::Status
4552   relgot_hi16(unsigned char* view, int gp_offset, unsigned int r_type)
4553   {
4554     mips_reloc_unshuffle(view, r_type, false);
4555     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4556     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4557     Valtype32 x = gp_offset;
4558     x = ((x + 0x8000) >> 16) & 0xffff;
4559     val = Bits<32>::bit_select32(val, x, 0xffff);
4560     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4561     mips_reloc_shuffle(view, r_type, false);
4562     return This::STATUS_OKAY;
4563   }
4564
4565   // R_MIPS_GOT_LO16, R_MIPS_CALL_LO16,
4566   // R_MICROMIPS_GOT_LO16, R_MICROMIPS_CALL_LO16
4567   static inline typename This::Status
4568   relgot_lo16(unsigned char* view, int gp_offset, unsigned int r_type)
4569   {
4570     mips_reloc_unshuffle(view, r_type, false);
4571     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4572     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4573     Valtype32 x = gp_offset;
4574     val = Bits<32>::bit_select32(val, x, 0xffff);
4575     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4576     mips_reloc_shuffle(view, r_type, false);
4577     return This::STATUS_OKAY;
4578   }
4579
4580   // R_MIPS_GPREL16, R_MIPS16_GPREL, R_MIPS_LITERAL, R_MICROMIPS_LITERAL
4581   // R_MICROMIPS_GPREL7_S2, R_MICROMIPS_GPREL16
4582   static inline typename This::Status
4583   relgprel(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4584            const Symbol_value<size>* psymval, Mips_address gp,
4585            Mips_address addend_a, bool extract_addend, bool local,
4586            unsigned int r_type)
4587   {
4588     mips_reloc_unshuffle(view, r_type, false);
4589     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4590     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4591
4592     Valtype32 addend;
4593     if (extract_addend)
4594       {
4595         if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2)
4596           addend = (val & 0x7f) << 2;
4597         else
4598           addend = val & 0xffff;
4599         // Only sign-extend the addend if it was extracted from the
4600         // instruction.  If the addend was separate, leave it alone,
4601         // otherwise we may lose significant bits.
4602         addend = Bits<16>::sign_extend32(addend);
4603       }
4604     else
4605       addend = addend_a;
4606
4607     Valtype32 x = psymval->value(object, addend) - gp;
4608
4609     // If the symbol was local, any earlier relocatable links will
4610     // have adjusted its addend with the gp offset, so compensate
4611     // for that now.  Don't do it for symbols forced local in this
4612     // link, though, since they won't have had the gp offset applied
4613     // to them before.
4614     if (local)
4615       x += object->gp_value();
4616
4617     if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2)
4618       val = Bits<32>::bit_select32(val, x, 0x7f);
4619     else
4620       val = Bits<32>::bit_select32(val, x, 0xffff);
4621     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4622     mips_reloc_shuffle(view, r_type, false);
4623     if (Bits<16>::has_overflow32(x))
4624       {
4625         gold_error(_("small-data section exceeds 64KB; lower small-data size "
4626                      "limit (see option -G)"));
4627         return This::STATUS_OVERFLOW;
4628       }
4629     return This::STATUS_OKAY;
4630   }
4631
4632   // R_MIPS_GPREL32
4633   static inline typename This::Status
4634   relgprel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4635              const Symbol_value<size>* psymval, Mips_address gp,
4636              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4637   {
4638     mips_reloc_unshuffle(view, r_type, false);
4639     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4640     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4641     Valtype32 addend = extract_addend ? val : addend_a;
4642
4643     // R_MIPS_GPREL32 relocations are defined for local symbols only.
4644     Valtype32 x = psymval->value(object, addend) + object->gp_value() - gp;
4645     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4646     mips_reloc_shuffle(view, r_type, false);
4647     return This::STATUS_OKAY;
4648  }
4649
4650   // R_MIPS_TLS_TPREL_HI16, R_MIPS16_TLS_TPREL_HI16, R_MICROMIPS_TLS_TPREL_HI16
4651   // R_MIPS_TLS_DTPREL_HI16, R_MIPS16_TLS_DTPREL_HI16,
4652   // R_MICROMIPS_TLS_DTPREL_HI16
4653   static inline typename This::Status
4654   tlsrelhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4655              const Symbol_value<size>* psymval, Valtype32 tp_offset,
4656              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4657   {
4658     mips_reloc_unshuffle(view, r_type, false);
4659     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4660     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4661     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4662
4663     // tls symbol values are relative to tls_segment()->vaddr()
4664     Valtype32 x = ((psymval->value(object, addend) - tp_offset) + 0x8000) >> 16;
4665     val = Bits<32>::bit_select32(val, x, 0xffff);
4666     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4667     mips_reloc_shuffle(view, r_type, false);
4668     return This::STATUS_OKAY;
4669   }
4670
4671   // R_MIPS_TLS_TPREL_LO16, R_MIPS16_TLS_TPREL_LO16, R_MICROMIPS_TLS_TPREL_LO16,
4672   // R_MIPS_TLS_DTPREL_LO16, R_MIPS16_TLS_DTPREL_LO16,
4673   // R_MICROMIPS_TLS_DTPREL_LO16,
4674   static inline typename This::Status
4675   tlsrello16(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4676              const Symbol_value<size>* psymval, Valtype32 tp_offset,
4677              Mips_address addend_a, bool extract_addend, unsigned int r_type)
4678   {
4679     mips_reloc_unshuffle(view, r_type, false);
4680     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4681     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4682     Valtype32 addend = extract_addend ? val & 0xffff : addend_a;
4683
4684     // tls symbol values are relative to tls_segment()->vaddr()
4685     Valtype32 x = psymval->value(object, addend) - tp_offset;
4686     val = Bits<32>::bit_select32(val, x, 0xffff);
4687     elfcpp::Swap<32, big_endian>::writeval(wv, val);
4688     mips_reloc_shuffle(view, r_type, false);
4689     return This::STATUS_OKAY;
4690   }
4691
4692   // R_MIPS_TLS_TPREL32, R_MIPS_TLS_TPREL64,
4693   // R_MIPS_TLS_DTPREL32, R_MIPS_TLS_DTPREL64
4694   static inline typename This::Status
4695   tlsrel32(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4696            const Symbol_value<size>* psymval, Valtype32 tp_offset,
4697            Mips_address addend_a, bool extract_addend, unsigned int r_type)
4698   {
4699     mips_reloc_unshuffle(view, r_type, false);
4700     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4701     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4702     Valtype32 addend = extract_addend ? val : addend_a;
4703
4704     // tls symbol values are relative to tls_segment()->vaddr()
4705     Valtype32 x = psymval->value(object, addend) - tp_offset;
4706     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4707     mips_reloc_shuffle(view, r_type, false);
4708     return This::STATUS_OKAY;
4709   }
4710
4711   // R_MIPS_SUB, R_MICROMIPS_SUB
4712   static inline typename This::Status
4713   relsub(unsigned char* view, const Mips_relobj<size, big_endian>* object,
4714          const Symbol_value<size>* psymval, Mips_address addend_a,
4715          bool extract_addend, unsigned int r_type)
4716   {
4717     mips_reloc_unshuffle(view, r_type, false);
4718     Valtype32* wv = reinterpret_cast<Valtype32*>(view);
4719     Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv);
4720     Valtype32 addend = extract_addend ? val : addend_a;
4721
4722     Valtype32 x = psymval->value(object, -addend);
4723     elfcpp::Swap<32, big_endian>::writeval(wv, x);
4724     mips_reloc_shuffle(view, r_type, false);
4725     return This::STATUS_OKAY;
4726  }
4727 };
4728
4729 template<int size, bool big_endian>
4730 typename std::list<reloc_high<size, big_endian> >
4731     Mips_relocate_functions<size, big_endian>::hi16_relocs;
4732
4733 template<int size, bool big_endian>
4734 typename std::list<reloc_high<size, big_endian> >
4735     Mips_relocate_functions<size, big_endian>::got16_relocs;
4736
4737 // Mips_got_info methods.
4738
4739 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
4740 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
4741
4742 template<int size, bool big_endian>
4743 void
4744 Mips_got_info<size, big_endian>::record_local_got_symbol(
4745     Mips_relobj<size, big_endian>* object, unsigned int symndx,
4746     Mips_address addend, unsigned int r_type, unsigned int shndx)
4747 {
4748   Mips_got_entry<size, big_endian>* entry =
4749     new Mips_got_entry<size, big_endian>(object, symndx, addend,
4750                                          mips_elf_reloc_tls_type(r_type),
4751                                          shndx);
4752   this->record_got_entry(entry, object);
4753 }
4754
4755 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
4756 // in OBJECT.  FOR_CALL is true if the caller is only interested in
4757 // using the GOT entry for calls.  DYN_RELOC is true if R_TYPE is a dynamic
4758 // relocation.
4759
4760 template<int size, bool big_endian>
4761 void
4762 Mips_got_info<size, big_endian>::record_global_got_symbol(
4763     Mips_symbol<size>* mips_sym, Mips_relobj<size, big_endian>* object,
4764     unsigned int r_type, bool dyn_reloc, bool for_call)
4765 {
4766   if (!for_call)
4767     mips_sym->set_got_not_only_for_calls();
4768
4769   // A global symbol in the GOT must also be in the dynamic symbol table.
4770   if (!mips_sym->needs_dynsym_entry())
4771     {
4772       switch (mips_sym->visibility())
4773         {
4774         case elfcpp::STV_INTERNAL:
4775         case elfcpp::STV_HIDDEN:
4776           mips_sym->set_is_forced_local();
4777           break;
4778         default:
4779           mips_sym->set_needs_dynsym_entry();
4780           break;
4781         }
4782     }
4783
4784   unsigned char tls_type = mips_elf_reloc_tls_type(r_type);
4785   if (tls_type == GOT_TLS_NONE)
4786     this->global_got_symbols_.insert(mips_sym);
4787
4788   if (dyn_reloc)
4789     {
4790       if (mips_sym->global_got_area() == GGA_NONE)
4791         mips_sym->set_global_got_area(GGA_RELOC_ONLY);
4792       return;
4793     }
4794
4795   Mips_got_entry<size, big_endian>* entry =
4796     new Mips_got_entry<size, big_endian>(object, mips_sym, tls_type);
4797
4798   this->record_got_entry(entry, object);
4799 }
4800
4801 // Add ENTRY to master GOT and to OBJECT's GOT.
4802
4803 template<int size, bool big_endian>
4804 void
4805 Mips_got_info<size, big_endian>::record_got_entry(
4806     Mips_got_entry<size, big_endian>* entry,
4807     Mips_relobj<size, big_endian>* object)
4808 {
4809   if (this->got_entries_.find(entry) == this->got_entries_.end())
4810     this->got_entries_.insert(entry);
4811
4812   // Create the GOT entry for the OBJECT's GOT.
4813   Mips_got_info<size, big_endian>* g = object->get_or_create_got_info();
4814   Mips_got_entry<size, big_endian>* entry2 =
4815     new Mips_got_entry<size, big_endian>(*entry);
4816
4817   if (g->got_entries_.find(entry2) == g->got_entries_.end())
4818     g->got_entries_.insert(entry2);
4819 }
4820
4821 // Record that OBJECT has a page relocation against symbol SYMNDX and
4822 // that ADDEND is the addend for that relocation.
4823 // This function creates an upper bound on the number of GOT slots
4824 // required; no attempt is made to combine references to non-overridable
4825 // global symbols across multiple input files.
4826
4827 template<int size, bool big_endian>
4828 void
4829 Mips_got_info<size, big_endian>::record_got_page_entry(
4830     Mips_relobj<size, big_endian>* object, unsigned int symndx, int addend)
4831 {
4832   struct Got_page_range **range_ptr, *range;
4833   int old_pages, new_pages;
4834
4835   // Find the Got_page_entry for this symbol.
4836   Got_page_entry* entry = new Got_page_entry(object, symndx);
4837   typename Got_page_entry_set::iterator it =
4838     this->got_page_entries_.find(entry);
4839   if (it != this->got_page_entries_.end())
4840     entry = *it;
4841   else
4842     this->got_page_entries_.insert(entry);
4843
4844   // Add the same entry to the OBJECT's GOT.
4845   Got_page_entry* entry2 = NULL;
4846   Mips_got_info<size, big_endian>* g2 = object->get_or_create_got_info();
4847   if (g2->got_page_entries_.find(entry) == g2->got_page_entries_.end())
4848     {
4849       entry2 = new Got_page_entry(*entry);
4850       g2->got_page_entries_.insert(entry2);
4851     }
4852
4853   // Skip over ranges whose maximum extent cannot share a page entry
4854   // with ADDEND.
4855   range_ptr = &entry->ranges;
4856   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4857     range_ptr = &(*range_ptr)->next;
4858
4859   // If we scanned to the end of the list, or found a range whose
4860   // minimum extent cannot share a page entry with ADDEND, create
4861   // a new singleton range.
4862   range = *range_ptr;
4863   if (!range || addend < range->min_addend - 0xffff)
4864     {
4865       range = new Got_page_range();
4866       range->next = *range_ptr;
4867       range->min_addend = addend;
4868       range->max_addend = addend;
4869
4870       *range_ptr = range;
4871       ++entry->num_pages;
4872       if (entry2 != NULL)
4873         ++entry2->num_pages;
4874       ++this->page_gotno_;
4875       ++g2->page_gotno_;
4876       return;
4877     }
4878
4879   // Remember how many pages the old range contributed.
4880   old_pages = range->get_max_pages();
4881
4882   // Update the ranges.
4883   if (addend < range->min_addend)
4884     range->min_addend = addend;
4885   else if (addend > range->max_addend)
4886     {
4887       if (range->next && addend >= range->next->min_addend - 0xffff)
4888         {
4889           old_pages += range->next->get_max_pages();
4890           range->max_addend = range->next->max_addend;
4891           range->next = range->next->next;
4892         }
4893       else
4894         range->max_addend = addend;
4895     }
4896
4897   // Record any change in the total estimate.
4898   new_pages = range->get_max_pages();
4899   if (old_pages != new_pages)
4900     {
4901       entry->num_pages += new_pages - old_pages;
4902       if (entry2 != NULL)
4903         entry2->num_pages += new_pages - old_pages;
4904       this->page_gotno_ += new_pages - old_pages;
4905       g2->page_gotno_ += new_pages - old_pages;
4906     }
4907 }
4908
4909 // Create all entries that should be in the local part of the GOT.
4910
4911 template<int size, bool big_endian>
4912 void
4913 Mips_got_info<size, big_endian>::add_local_entries(
4914     Target_mips<size, big_endian>* target, Layout* layout)
4915 {
4916   Mips_output_data_got<size, big_endian>* got = target->got_section();
4917   // First two GOT entries are reserved.  The first entry will be filled at
4918   // runtime.  The second entry will be used by some runtime loaders.
4919   got->add_constant(0);
4920   got->add_constant(target->mips_elf_gnu_got1_mask());
4921
4922   for (typename Got_entry_set::iterator
4923        p = this->got_entries_.begin();
4924        p != this->got_entries_.end();
4925        ++p)
4926     {
4927       Mips_got_entry<size, big_endian>* entry = *p;
4928       if (entry->is_for_local_symbol() && !entry->is_tls_entry())
4929         {
4930           got->add_local(entry->object(), entry->symndx(),
4931                          GOT_TYPE_STANDARD);
4932           unsigned int got_offset = entry->object()->local_got_offset(
4933               entry->symndx(), GOT_TYPE_STANDARD);
4934           if (got->multi_got() && this->index_ > 0
4935               && parameters->options().output_is_position_independent())
4936             target->rel_dyn_section(layout)->add_local(entry->object(),
4937                 entry->symndx(), elfcpp::R_MIPS_REL32, got, got_offset);
4938         }
4939     }
4940
4941   this->add_page_entries(target, layout);
4942
4943   // Add global entries that should be in the local area.
4944   for (typename Got_entry_set::iterator
4945        p = this->got_entries_.begin();
4946        p != this->got_entries_.end();
4947        ++p)
4948     {
4949       Mips_got_entry<size, big_endian>* entry = *p;
4950       if (!entry->is_for_global_symbol())
4951         continue;
4952
4953       Mips_symbol<size>* mips_sym = entry->sym();
4954       if (mips_sym->global_got_area() == GGA_NONE && !entry->is_tls_entry())
4955         {
4956           unsigned int got_type;
4957           if (!got->multi_got())
4958             got_type = GOT_TYPE_STANDARD;
4959           else
4960             got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_;
4961           if (got->add_global(mips_sym, got_type))
4962             {
4963               mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
4964               if (got->multi_got() && this->index_ > 0
4965                   && parameters->options().output_is_position_independent())
4966                 target->rel_dyn_section(layout)->add_symbolless_global_addend(
4967                     mips_sym, elfcpp::R_MIPS_REL32, got,
4968                     mips_sym->got_offset(got_type));
4969             }
4970         }
4971     }
4972 }
4973
4974 // Create GOT page entries.
4975
4976 template<int size, bool big_endian>
4977 void
4978 Mips_got_info<size, big_endian>::add_page_entries(
4979     Target_mips<size, big_endian>* target, Layout* layout)
4980 {
4981   if (this->page_gotno_ == 0)
4982     return;
4983
4984   Mips_output_data_got<size, big_endian>* got = target->got_section();
4985   this->got_page_offset_start_ = got->add_constant(0);
4986   if (got->multi_got() && this->index_ > 0
4987       && parameters->options().output_is_position_independent())
4988     target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got,
4989                                                   this->got_page_offset_start_);
4990   int num_entries = this->page_gotno_;
4991   unsigned int prev_offset = this->got_page_offset_start_;
4992   while (--num_entries > 0)
4993     {
4994       unsigned int next_offset = got->add_constant(0);
4995       if (got->multi_got() && this->index_ > 0
4996           && parameters->options().output_is_position_independent())
4997         target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got,
4998                                                       next_offset);
4999       gold_assert(next_offset == prev_offset + size/8);
5000       prev_offset = next_offset;
5001     }
5002   this->got_page_offset_next_ = this->got_page_offset_start_;
5003 }
5004
5005 // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY.
5006
5007 template<int size, bool big_endian>
5008 void
5009 Mips_got_info<size, big_endian>::add_global_entries(
5010     Target_mips<size, big_endian>* target, Layout* layout,
5011     unsigned int non_reloc_only_global_gotno)
5012 {
5013   Mips_output_data_got<size, big_endian>* got = target->got_section();
5014   // Add GGA_NORMAL entries.
5015   unsigned int count = 0;
5016   for (typename Got_entry_set::iterator
5017        p = this->got_entries_.begin();
5018        p != this->got_entries_.end();
5019        ++p)
5020     {
5021       Mips_got_entry<size, big_endian>* entry = *p;
5022       if (!entry->is_for_global_symbol())
5023         continue;
5024
5025       Mips_symbol<size>* mips_sym = entry->sym();
5026       if (mips_sym->global_got_area() != GGA_NORMAL)
5027         continue;
5028
5029       unsigned int got_type;
5030       if (!got->multi_got())
5031         got_type = GOT_TYPE_STANDARD;
5032       else
5033         // In multi-GOT links, global symbol can be in both primary and
5034         // secondary GOT(s).  By creating custom GOT type
5035         // (GOT_TYPE_STANDARD_MULTIGOT + got_index) we ensure that symbol
5036         // is added to secondary GOT(s).
5037         got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_;
5038       if (!got->add_global(mips_sym, got_type))
5039         continue;
5040
5041       mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
5042       if (got->multi_got() && this->index_ == 0)
5043         count++;
5044       if (got->multi_got() && this->index_ > 0)
5045         {
5046           if (parameters->options().output_is_position_independent()
5047               || (!parameters->doing_static_link()
5048                   && mips_sym->is_from_dynobj() && !mips_sym->is_undefined()))
5049             {
5050               target->rel_dyn_section(layout)->add_global(
5051                   mips_sym, elfcpp::R_MIPS_REL32, got,
5052                   mips_sym->got_offset(got_type));
5053               got->add_secondary_got_reloc(mips_sym->got_offset(got_type),
5054                                            elfcpp::R_MIPS_REL32, mips_sym);
5055             }
5056         }
5057     }
5058
5059   if (!got->multi_got() || this->index_ == 0)
5060     {
5061       if (got->multi_got())
5062         {
5063           // We need to allocate space in the primary GOT for GGA_NORMAL entries
5064           // of secondary GOTs, to ensure that GOT offsets of GGA_RELOC_ONLY
5065           // entries correspond to dynamic symbol indexes.
5066           while (count < non_reloc_only_global_gotno)
5067             {
5068               got->add_constant(0);
5069               ++count;
5070             }
5071         }
5072
5073       // Add GGA_RELOC_ONLY entries.
5074       got->add_reloc_only_entries();
5075     }
5076 }
5077
5078 // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
5079
5080 template<int size, bool big_endian>
5081 void
5082 Mips_got_info<size, big_endian>::add_reloc_only_entries(
5083     Mips_output_data_got<size, big_endian>* got)
5084 {
5085   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5086        p = this->global_got_symbols_.begin();
5087        p != this->global_got_symbols_.end();
5088        ++p)
5089     {
5090       Mips_symbol<size>* mips_sym = *p;
5091       if (mips_sym->global_got_area() == GGA_RELOC_ONLY)
5092         {
5093           unsigned int got_type;
5094           if (!got->multi_got())
5095             got_type = GOT_TYPE_STANDARD;
5096           else
5097             got_type = GOT_TYPE_STANDARD_MULTIGOT;
5098           if (got->add_global(mips_sym, got_type))
5099             mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type));
5100         }
5101     }
5102 }
5103
5104 // Create TLS GOT entries.
5105
5106 template<int size, bool big_endian>
5107 void
5108 Mips_got_info<size, big_endian>::add_tls_entries(
5109     Target_mips<size, big_endian>* target, Layout* layout)
5110 {
5111   Mips_output_data_got<size, big_endian>* got = target->got_section();
5112   // Add local tls entries.
5113   for (typename Got_entry_set::iterator
5114        p = this->got_entries_.begin();
5115        p != this->got_entries_.end();
5116        ++p)
5117     {
5118       Mips_got_entry<size, big_endian>* entry = *p;
5119       if (!entry->is_tls_entry() || !entry->is_for_local_symbol())
5120         continue;
5121
5122       if (entry->tls_type() == GOT_TLS_GD)
5123         {
5124           unsigned int got_type = GOT_TYPE_TLS_PAIR;
5125           unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5126                                              : elfcpp::R_MIPS_TLS_DTPMOD64);
5127           unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32
5128                                              : elfcpp::R_MIPS_TLS_DTPREL64);
5129
5130           if (!parameters->doing_static_link())
5131             {
5132               got->add_local_pair_with_rel(entry->object(), entry->symndx(),
5133                                            entry->shndx(), got_type,
5134                                            target->rel_dyn_section(layout),
5135                                            r_type1);
5136               unsigned int got_offset =
5137                 entry->object()->local_got_offset(entry->symndx(), got_type);
5138               got->add_static_reloc(got_offset + size/8, r_type2,
5139                                     entry->object(), entry->symndx());
5140             }
5141           else
5142             {
5143               // We are doing a static link.  Mark it as belong to module 1,
5144               // the executable.
5145               unsigned int got_offset = got->add_constant(1);
5146               entry->object()->set_local_got_offset(entry->symndx(), got_type,
5147                                                     got_offset);
5148               got->add_constant(0);
5149               got->add_static_reloc(got_offset + size/8, r_type2,
5150                                     entry->object(), entry->symndx());
5151             }
5152         }
5153       else if (entry->tls_type() == GOT_TLS_IE)
5154         {
5155           unsigned int got_type = GOT_TYPE_TLS_OFFSET;
5156           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32
5157                                             : elfcpp::R_MIPS_TLS_TPREL64);
5158           if (!parameters->doing_static_link())
5159             got->add_local_with_rel(entry->object(), entry->symndx(), got_type,
5160                                     target->rel_dyn_section(layout), r_type);
5161           else
5162             {
5163               got->add_local(entry->object(), entry->symndx(), got_type);
5164               unsigned int got_offset =
5165                   entry->object()->local_got_offset(entry->symndx(), got_type);
5166               got->add_static_reloc(got_offset, r_type, entry->object(),
5167                                     entry->symndx());
5168             }
5169         }
5170       else if (entry->tls_type() == GOT_TLS_LDM)
5171         {
5172           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5173                                             : elfcpp::R_MIPS_TLS_DTPMOD64);
5174           unsigned int got_offset;
5175           if (!parameters->doing_static_link())
5176             {
5177               got_offset = got->add_constant(0);
5178               target->rel_dyn_section(layout)->add_local(
5179                   entry->object(), 0, r_type, got, got_offset);
5180             }
5181           else
5182             // We are doing a static link.  Just mark it as belong to module 1,
5183             // the executable.
5184             got_offset = got->add_constant(1);
5185
5186           got->add_constant(0);
5187           got->set_tls_ldm_offset(got_offset, entry->object());
5188         }
5189       else
5190         gold_unreachable();
5191     }
5192
5193   // Add global tls entries.
5194   for (typename Got_entry_set::iterator
5195        p = this->got_entries_.begin();
5196        p != this->got_entries_.end();
5197        ++p)
5198     {
5199       Mips_got_entry<size, big_endian>* entry = *p;
5200       if (!entry->is_tls_entry() || !entry->is_for_global_symbol())
5201         continue;
5202
5203       Mips_symbol<size>* mips_sym = entry->sym();
5204       if (entry->tls_type() == GOT_TLS_GD)
5205         {
5206           unsigned int got_type;
5207           if (!got->multi_got())
5208             got_type = GOT_TYPE_TLS_PAIR;
5209           else
5210             got_type = GOT_TYPE_TLS_PAIR_MULTIGOT + this->index_;
5211           unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
5212                                              : elfcpp::R_MIPS_TLS_DTPMOD64);
5213           unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32
5214                                              : elfcpp::R_MIPS_TLS_DTPREL64);
5215           if (!parameters->doing_static_link())
5216             got->add_global_pair_with_rel(mips_sym, got_type,
5217                              target->rel_dyn_section(layout), r_type1, r_type2);
5218           else
5219             {
5220               // Add a GOT pair for for R_MIPS_TLS_GD.  The creates a pair of
5221               // GOT entries.  The first one is initialized to be 1, which is the
5222               // module index for the main executable and the second one 0.  A
5223               // reloc of the type R_MIPS_TLS_DTPREL32/64 will be created for
5224               // the second GOT entry and will be applied by gold.
5225               unsigned int got_offset = got->add_constant(1);
5226               mips_sym->set_got_offset(got_type, got_offset);
5227               got->add_constant(0);
5228               got->add_static_reloc(got_offset + size/8, r_type2, mips_sym);
5229             }
5230         }
5231       else if (entry->tls_type() == GOT_TLS_IE)
5232         {
5233           unsigned int got_type;
5234           if (!got->multi_got())
5235             got_type = GOT_TYPE_TLS_OFFSET;
5236           else
5237             got_type = GOT_TYPE_TLS_OFFSET_MULTIGOT + this->index_;
5238           unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32
5239                                             : elfcpp::R_MIPS_TLS_TPREL64);
5240           if (!parameters->doing_static_link())
5241             got->add_global_with_rel(mips_sym, got_type,
5242                                      target->rel_dyn_section(layout), r_type);
5243           else
5244             {
5245               got->add_global(mips_sym, got_type);
5246               unsigned int got_offset = mips_sym->got_offset(got_type);
5247               got->add_static_reloc(got_offset, r_type, mips_sym);
5248             }
5249         }
5250       else
5251         gold_unreachable();
5252     }
5253 }
5254
5255 // Decide whether the symbol needs an entry in the global part of the primary
5256 // GOT, setting global_got_area accordingly.  Count the number of global
5257 // symbols that are in the primary GOT only because they have dynamic
5258 // relocations R_MIPS_REL32 against them (reloc_only_gotno).
5259
5260 template<int size, bool big_endian>
5261 void
5262 Mips_got_info<size, big_endian>::count_got_symbols(Symbol_table* symtab)
5263 {
5264   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5265        p = this->global_got_symbols_.begin();
5266        p != this->global_got_symbols_.end();
5267        ++p)
5268     {
5269       Mips_symbol<size>* sym = *p;
5270       // Make a final decision about whether the symbol belongs in the
5271       // local or global GOT.  Symbols that bind locally can (and in the
5272       // case of forced-local symbols, must) live in the local GOT.
5273       // Those that are aren't in the dynamic symbol table must also
5274       // live in the local GOT.
5275
5276       if (!sym->should_add_dynsym_entry(symtab)
5277           || (sym->got_only_for_calls()
5278               ? symbol_calls_local(sym, sym->should_add_dynsym_entry(symtab))
5279               : symbol_references_local(sym,
5280                                         sym->should_add_dynsym_entry(symtab))))
5281         // The symbol belongs in the local GOT.  We no longer need this
5282         // entry if it was only used for relocations; those relocations
5283         // will be against the null or section symbol instead.
5284         sym->set_global_got_area(GGA_NONE);
5285       else if (sym->global_got_area() == GGA_RELOC_ONLY)
5286         {
5287           ++this->reloc_only_gotno_;
5288           ++this->global_gotno_ ;
5289         }
5290     }
5291 }
5292
5293 // Return the offset of GOT page entry for VALUE.  Initialize the entry with
5294 // VALUE if it is not initialized.
5295
5296 template<int size, bool big_endian>
5297 unsigned int
5298 Mips_got_info<size, big_endian>::get_got_page_offset(Mips_address value,
5299     Mips_output_data_got<size, big_endian>* got)
5300 {
5301   typename Got_page_offsets::iterator it = this->got_page_offsets_.find(value);
5302   if (it != this->got_page_offsets_.end())
5303     return it->second;
5304
5305   gold_assert(this->got_page_offset_next_ < this->got_page_offset_start_
5306               + (size/8) * this->page_gotno_);
5307
5308   unsigned int got_offset = this->got_page_offset_next_;
5309   this->got_page_offsets_[value] = got_offset;
5310   this->got_page_offset_next_ += size/8;
5311   got->update_got_entry(got_offset, value);
5312   return got_offset;
5313 }
5314
5315 // Remove lazy-binding stubs for global symbols in this GOT.
5316
5317 template<int size, bool big_endian>
5318 void
5319 Mips_got_info<size, big_endian>::remove_lazy_stubs(
5320     Target_mips<size, big_endian>* target)
5321 {
5322   for (typename Got_entry_set::iterator
5323        p = this->got_entries_.begin();
5324        p != this->got_entries_.end();
5325        ++p)
5326     {
5327       Mips_got_entry<size, big_endian>* entry = *p;
5328       if (entry->is_for_global_symbol())
5329         target->remove_lazy_stub_entry(entry->sym());
5330     }
5331 }
5332
5333 // Count the number of GOT entries required.
5334
5335 template<int size, bool big_endian>
5336 void
5337 Mips_got_info<size, big_endian>::count_got_entries()
5338 {
5339   for (typename Got_entry_set::iterator
5340        p = this->got_entries_.begin();
5341        p != this->got_entries_.end();
5342        ++p)
5343     {
5344       this->count_got_entry(*p);
5345     }
5346 }
5347
5348 // Count the number of GOT entries required by ENTRY.  Accumulate the result.
5349
5350 template<int size, bool big_endian>
5351 void
5352 Mips_got_info<size, big_endian>::count_got_entry(
5353     Mips_got_entry<size, big_endian>* entry)
5354 {
5355   if (entry->is_tls_entry())
5356     this->tls_gotno_ += mips_tls_got_entries(entry->tls_type());
5357   else if (entry->is_for_local_symbol()
5358            || entry->sym()->global_got_area() == GGA_NONE)
5359     ++this->local_gotno_;
5360   else
5361     ++this->global_gotno_;
5362 }
5363
5364 // Add FROM's GOT entries.
5365
5366 template<int size, bool big_endian>
5367 void
5368 Mips_got_info<size, big_endian>::add_got_entries(
5369     Mips_got_info<size, big_endian>* from)
5370 {
5371   for (typename Got_entry_set::iterator
5372        p = from->got_entries_.begin();
5373        p != from->got_entries_.end();
5374        ++p)
5375     {
5376       Mips_got_entry<size, big_endian>* entry = *p;
5377       if (this->got_entries_.find(entry) == this->got_entries_.end())
5378         {
5379           Mips_got_entry<size, big_endian>* entry2 =
5380             new Mips_got_entry<size, big_endian>(*entry);
5381           this->got_entries_.insert(entry2);
5382           this->count_got_entry(entry);
5383         }
5384     }
5385 }
5386
5387 // Add FROM's GOT page entries.
5388
5389 template<int size, bool big_endian>
5390 void
5391 Mips_got_info<size, big_endian>::add_got_page_entries(
5392     Mips_got_info<size, big_endian>* from)
5393 {
5394   for (typename Got_page_entry_set::iterator
5395        p = from->got_page_entries_.begin();
5396        p != from->got_page_entries_.end();
5397        ++p)
5398     {
5399       Got_page_entry* entry = *p;
5400       if (this->got_page_entries_.find(entry) == this->got_page_entries_.end())
5401         {
5402           Got_page_entry* entry2 = new Got_page_entry(*entry);
5403           this->got_page_entries_.insert(entry2);
5404           this->page_gotno_ += entry->num_pages;
5405         }
5406     }
5407 }
5408
5409 // Mips_output_data_got methods.
5410
5411 // Lay out the GOT.  Add local, global and TLS entries.  If GOT is
5412 // larger than 64K, create multi-GOT.
5413
5414 template<int size, bool big_endian>
5415 void
5416 Mips_output_data_got<size, big_endian>::lay_out_got(Layout* layout,
5417     Symbol_table* symtab, const Input_objects* input_objects)
5418 {
5419   // Decide which symbols need to go in the global part of the GOT and
5420   // count the number of reloc-only GOT symbols.
5421   this->master_got_info_->count_got_symbols(symtab);
5422
5423   // Count the number of GOT entries.
5424   this->master_got_info_->count_got_entries();
5425
5426   unsigned int got_size = this->master_got_info_->got_size();
5427   if (got_size > Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE)
5428     this->lay_out_multi_got(layout, input_objects);
5429   else
5430     {
5431       // Record that all objects use single GOT.
5432       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
5433            p != input_objects->relobj_end();
5434            ++p)
5435         {
5436           Mips_relobj<size, big_endian>* object =
5437             Mips_relobj<size, big_endian>::as_mips_relobj(*p);
5438           if (object->get_got_info() != NULL)
5439             object->set_got_info(this->master_got_info_);
5440         }
5441
5442       this->master_got_info_->add_local_entries(this->target_, layout);
5443       this->master_got_info_->add_global_entries(this->target_, layout,
5444                                                  /*not used*/-1U);
5445       this->master_got_info_->add_tls_entries(this->target_, layout);
5446     }
5447 }
5448
5449 // Create multi-GOT.  For every GOT, add local, global and TLS entries.
5450
5451 template<int size, bool big_endian>
5452 void
5453 Mips_output_data_got<size, big_endian>::lay_out_multi_got(Layout* layout,
5454     const Input_objects* input_objects)
5455 {
5456   // Try to merge the GOTs of input objects together, as long as they
5457   // don't seem to exceed the maximum GOT size, choosing one of them
5458   // to be the primary GOT.
5459   this->merge_gots(input_objects);
5460
5461   // Every symbol that is referenced in a dynamic relocation must be
5462   // present in the primary GOT.
5463   this->primary_got_->set_global_gotno(this->master_got_info_->global_gotno());
5464
5465   // Add GOT entries.
5466   unsigned int i = 0;
5467   unsigned int offset = 0;
5468   Mips_got_info<size, big_endian>* g = this->primary_got_;
5469   do
5470     {
5471       g->set_index(i);
5472       g->set_offset(offset);
5473
5474       g->add_local_entries(this->target_, layout);
5475       if (i == 0)
5476         g->add_global_entries(this->target_, layout,
5477                               (this->master_got_info_->global_gotno()
5478                                - this->master_got_info_->reloc_only_gotno()));
5479       else
5480         g->add_global_entries(this->target_, layout, /*not used*/-1U);
5481       g->add_tls_entries(this->target_, layout);
5482
5483       // Forbid global symbols in every non-primary GOT from having
5484       // lazy-binding stubs.
5485       if (i > 0)
5486         g->remove_lazy_stubs(this->target_);
5487
5488       ++i;
5489       offset += g->got_size();
5490       g = g->next();
5491     }
5492   while (g);
5493 }
5494
5495 // Attempt to merge GOTs of different input objects.  Try to use as much as
5496 // possible of the primary GOT, since it doesn't require explicit dynamic
5497 // relocations, but don't use objects that would reference global symbols
5498 // out of the addressable range.  Failing the primary GOT, attempt to merge
5499 // with the current GOT, or finish the current GOT and then make make the new
5500 // GOT current.
5501
5502 template<int size, bool big_endian>
5503 void
5504 Mips_output_data_got<size, big_endian>::merge_gots(
5505     const Input_objects* input_objects)
5506 {
5507   gold_assert(this->primary_got_ == NULL);
5508   Mips_got_info<size, big_endian>* current = NULL;
5509
5510   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
5511        p != input_objects->relobj_end();
5512        ++p)
5513     {
5514       Mips_relobj<size, big_endian>* object =
5515         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
5516
5517       Mips_got_info<size, big_endian>* g = object->get_got_info();
5518       if (g == NULL)
5519         continue;
5520
5521       g->count_got_entries();
5522
5523       // Work out the number of page, local and TLS entries.
5524       unsigned int estimate = this->master_got_info_->page_gotno();
5525       if (estimate > g->page_gotno())
5526         estimate = g->page_gotno();
5527       estimate += g->local_gotno() + g->tls_gotno();
5528
5529       // We place TLS GOT entries after both locals and globals.  The globals
5530       // for the primary GOT may overflow the normal GOT size limit, so be
5531       // sure not to merge a GOT which requires TLS with the primary GOT in that
5532       // case.  This doesn't affect non-primary GOTs.
5533       estimate += (g->tls_gotno() > 0 ? this->master_got_info_->global_gotno()
5534                                       : g->global_gotno());
5535
5536       unsigned int max_count =
5537         Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2;
5538       if (estimate <= max_count)
5539         {
5540           // If we don't have a primary GOT, use it as
5541           // a starting point for the primary GOT.
5542           if (!this->primary_got_)
5543             {
5544               this->primary_got_ = g;
5545               continue;
5546             }
5547
5548           // Try merging with the primary GOT.
5549           if (this->merge_got_with(g, object, this->primary_got_))
5550             continue;
5551         }
5552
5553       // If we can merge with the last-created GOT, do it.
5554       if (current && this->merge_got_with(g, object, current))
5555         continue;
5556
5557       // Well, we couldn't merge, so create a new GOT.  Don't check if it
5558       // fits; if it turns out that it doesn't, we'll get relocation
5559       // overflows anyway.
5560       g->set_next(current);
5561       current = g;
5562     }
5563
5564   // If we do not find any suitable primary GOT, create an empty one.
5565   if (this->primary_got_ == NULL)
5566     this->primary_got_ = new Mips_got_info<size, big_endian>();
5567
5568   // Link primary GOT with secondary GOTs.
5569   this->primary_got_->set_next(current);
5570 }
5571
5572 // Consider merging FROM, which is OBJECT's GOT, into TO.  Return false if
5573 // this would lead to overflow, true if they were merged successfully.
5574
5575 template<int size, bool big_endian>
5576 bool
5577 Mips_output_data_got<size, big_endian>::merge_got_with(
5578     Mips_got_info<size, big_endian>* from,
5579     Mips_relobj<size, big_endian>* object,
5580     Mips_got_info<size, big_endian>* to)
5581 {
5582   // Work out how many page entries we would need for the combined GOT.
5583   unsigned int estimate = this->master_got_info_->page_gotno();
5584   if (estimate >= from->page_gotno() + to->page_gotno())
5585     estimate = from->page_gotno() + to->page_gotno();
5586
5587   // Conservatively estimate how many local and TLS entries would be needed.
5588   estimate += from->local_gotno() + to->local_gotno();
5589   estimate += from->tls_gotno() + to->tls_gotno();
5590
5591   // If we're merging with the primary got, any TLS relocations will
5592   // come after the full set of global entries.  Otherwise estimate those
5593   // conservatively as well.
5594   if (to == this->primary_got_ && (from->tls_gotno() + to->tls_gotno()) > 0)
5595     estimate += this->master_got_info_->global_gotno();
5596   else
5597     estimate += from->global_gotno() + to->global_gotno();
5598
5599   // Bail out if the combined GOT might be too big.
5600   unsigned int max_count =
5601     Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2;
5602   if (estimate > max_count)
5603     return false;
5604
5605   // Transfer the object's GOT information from FROM to TO.
5606   to->add_got_entries(from);
5607   to->add_got_page_entries(from);
5608
5609   // Record that OBJECT should use output GOT TO.
5610   object->set_got_info(to);
5611
5612   return true;
5613 }
5614
5615 // Write out the GOT.
5616
5617 template<int size, bool big_endian>
5618 void
5619 Mips_output_data_got<size, big_endian>::do_write(Output_file* of)
5620 {
5621   // Call parent to write out GOT.
5622   Output_data_got<size, big_endian>::do_write(of);
5623
5624   const off_t offset = this->offset();
5625   const section_size_type oview_size =
5626     convert_to_section_size_type(this->data_size());
5627   unsigned char* const oview = of->get_output_view(offset, oview_size);
5628
5629   // Needed for fixing values of .got section.
5630   this->got_view_ = oview;
5631
5632   // Write lazy stub addresses.
5633   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5634        p = this->master_got_info_->global_got_symbols().begin();
5635        p != this->master_got_info_->global_got_symbols().end();
5636        ++p)
5637     {
5638       Mips_symbol<size>* mips_sym = *p;
5639       if (mips_sym->has_lazy_stub())
5640         {
5641           Valtype* wv = reinterpret_cast<Valtype*>(
5642             oview + this->get_primary_got_offset(mips_sym));
5643           Valtype value =
5644             this->target_->mips_stubs_section()->stub_address(mips_sym);
5645           elfcpp::Swap<size, big_endian>::writeval(wv, value);
5646         }
5647     }
5648
5649   // Add +1 to GGA_NONE nonzero MIPS16 and microMIPS entries.
5650   for (typename Unordered_set<Mips_symbol<size>*>::iterator
5651        p = this->master_got_info_->global_got_symbols().begin();
5652        p != this->master_got_info_->global_got_symbols().end();
5653        ++p)
5654     {
5655       Mips_symbol<size>* mips_sym = *p;
5656       if (!this->multi_got()
5657           && (mips_sym->is_mips16() || mips_sym->is_micromips())
5658           && mips_sym->global_got_area() == GGA_NONE
5659           && mips_sym->has_got_offset(GOT_TYPE_STANDARD))
5660         {
5661           Valtype* wv = reinterpret_cast<Valtype*>(
5662             oview + mips_sym->got_offset(GOT_TYPE_STANDARD));
5663           Valtype value = elfcpp::Swap<size, big_endian>::readval(wv);
5664           if (value != 0)
5665             {
5666               value |= 1;
5667               elfcpp::Swap<size, big_endian>::writeval(wv, value);
5668             }
5669         }
5670     }
5671
5672   if (!this->secondary_got_relocs_.empty())
5673     {
5674       // Fixup for the secondary GOT R_MIPS_REL32 relocs.  For global
5675       // secondary GOT entries with non-zero initial value copy the value
5676       // to the corresponding primary GOT entry, and set the secondary GOT
5677       // entry to zero.
5678       // TODO(sasa): This is workaround.  It needs to be investigated further.
5679
5680       for (size_t i = 0; i < this->secondary_got_relocs_.size(); ++i)
5681         {
5682           Static_reloc& reloc(this->secondary_got_relocs_[i]);
5683           if (reloc.symbol_is_global())
5684             {
5685               Mips_symbol<size>* gsym = reloc.symbol();
5686               gold_assert(gsym != NULL);
5687
5688               unsigned got_offset = reloc.got_offset();
5689               gold_assert(got_offset < oview_size);
5690
5691               // Find primary GOT entry.
5692               Valtype* wv_prim = reinterpret_cast<Valtype*>(
5693                 oview + this->get_primary_got_offset(gsym));
5694
5695               // Find secondary GOT entry.
5696               Valtype* wv_sec = reinterpret_cast<Valtype*>(oview + got_offset);
5697
5698               Valtype value = elfcpp::Swap<size, big_endian>::readval(wv_sec);
5699               if (value != 0)
5700                 {
5701                   elfcpp::Swap<size, big_endian>::writeval(wv_prim, value);
5702                   elfcpp::Swap<size, big_endian>::writeval(wv_sec, 0);
5703                   gsym->set_applied_secondary_got_fixup();
5704                 }
5705             }
5706         }
5707
5708       of->write_output_view(offset, oview_size, oview);
5709     }
5710
5711   // We are done if there is no fix up.
5712   if (this->static_relocs_.empty())
5713     return;
5714
5715   Output_segment* tls_segment = this->layout_->tls_segment();
5716   gold_assert(tls_segment != NULL);
5717
5718   for (size_t i = 0; i < this->static_relocs_.size(); ++i)
5719     {
5720       Static_reloc& reloc(this->static_relocs_[i]);
5721
5722       Mips_address value;
5723       if (!reloc.symbol_is_global())
5724         {
5725           Sized_relobj_file<size, big_endian>* object = reloc.relobj();
5726           const Symbol_value<size>* psymval =
5727             object->local_symbol(reloc.index());
5728
5729           // We are doing static linking.  Issue an error and skip this
5730           // relocation if the symbol is undefined or in a discarded_section.
5731           bool is_ordinary;
5732           unsigned int shndx = psymval->input_shndx(&is_ordinary);
5733           if ((shndx == elfcpp::SHN_UNDEF)
5734               || (is_ordinary
5735                   && shndx != elfcpp::SHN_UNDEF
5736                   && !object->is_section_included(shndx)
5737                   && !this->symbol_table_->is_section_folded(object, shndx)))
5738             {
5739               gold_error(_("undefined or discarded local symbol %u from "
5740                            " object %s in GOT"),
5741                          reloc.index(), reloc.relobj()->name().c_str());
5742               continue;
5743             }
5744
5745           value = psymval->value(object, 0);
5746         }
5747       else
5748         {
5749           const Mips_symbol<size>* gsym = reloc.symbol();
5750           gold_assert(gsym != NULL);
5751
5752           // We are doing static linking.  Issue an error and skip this
5753           // relocation if the symbol is undefined or in a discarded_section
5754           // unless it is a weakly_undefined symbol.
5755           if ((gsym->is_defined_in_discarded_section() || gsym->is_undefined())
5756               && !gsym->is_weak_undefined())
5757             {
5758               gold_error(_("undefined or discarded symbol %s in GOT"),
5759                          gsym->name());
5760               continue;
5761             }
5762
5763           if (!gsym->is_weak_undefined())
5764             value = gsym->value();
5765           else
5766             value = 0;
5767         }
5768
5769       unsigned got_offset = reloc.got_offset();
5770       gold_assert(got_offset < oview_size);
5771
5772       Valtype* wv = reinterpret_cast<Valtype*>(oview + got_offset);
5773       Valtype x;
5774
5775       switch (reloc.r_type())
5776         {
5777         case elfcpp::R_MIPS_TLS_DTPMOD32:
5778         case elfcpp::R_MIPS_TLS_DTPMOD64:
5779           x = value;
5780           break;
5781         case elfcpp::R_MIPS_TLS_DTPREL32:
5782         case elfcpp::R_MIPS_TLS_DTPREL64:
5783           x = value - elfcpp::DTP_OFFSET;
5784           break;
5785         case elfcpp::R_MIPS_TLS_TPREL32:
5786         case elfcpp::R_MIPS_TLS_TPREL64:
5787           x = value - elfcpp::TP_OFFSET;
5788           break;
5789         default:
5790           gold_unreachable();
5791           break;
5792         }
5793
5794       elfcpp::Swap<size, big_endian>::writeval(wv, x);
5795     }
5796
5797   of->write_output_view(offset, oview_size, oview);
5798 }
5799
5800 // Mips_relobj methods.
5801
5802 // Count the local symbols.  The Mips backend needs to know if a symbol
5803 // is a MIPS16 or microMIPS function or not.  For global symbols, it is easy
5804 // because the Symbol object keeps the ELF symbol type and st_other field.
5805 // For local symbol it is harder because we cannot access this information.
5806 // So we override the do_count_local_symbol in parent and scan local symbols to
5807 // mark MIPS16 and microMIPS functions.  This is not the most efficient way but
5808 // I do not want to slow down other ports by calling a per symbol target hook
5809 // inside Sized_relobj_file<size, big_endian>::do_count_local_symbols.
5810
5811 template<int size, bool big_endian>
5812 void
5813 Mips_relobj<size, big_endian>::do_count_local_symbols(
5814     Stringpool_template<char>* pool,
5815     Stringpool_template<char>* dynpool)
5816 {
5817   // Ask parent to count the local symbols.
5818   Sized_relobj_file<size, big_endian>::do_count_local_symbols(pool, dynpool);
5819   const unsigned int loccount = this->local_symbol_count();
5820   if (loccount == 0)
5821     return;
5822
5823   // Initialize the mips16 and micromips function bit-vector.
5824   this->local_symbol_is_mips16_.resize(loccount, false);
5825   this->local_symbol_is_micromips_.resize(loccount, false);
5826
5827   // Read the symbol table section header.
5828   const unsigned int symtab_shndx = this->symtab_shndx();
5829   elfcpp::Shdr<size, big_endian>
5830     symtabshdr(this, this->elf_file()->section_header(symtab_shndx));
5831   gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
5832
5833   // Read the local symbols.
5834   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
5835   gold_assert(loccount == symtabshdr.get_sh_info());
5836   off_t locsize = loccount * sym_size;
5837   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
5838                                               locsize, true, true);
5839
5840   // Loop over the local symbols and mark any MIPS16 or microMIPS local symbols.
5841
5842   // Skip the first dummy symbol.
5843   psyms += sym_size;
5844   for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
5845     {
5846       elfcpp::Sym<size, big_endian> sym(psyms);
5847       unsigned char st_other = sym.get_st_other();
5848       this->local_symbol_is_mips16_[i] = elfcpp::elf_st_is_mips16(st_other);
5849       this->local_symbol_is_micromips_[i] =
5850         elfcpp::elf_st_is_micromips(st_other);
5851     }
5852 }
5853
5854 // Read the symbol information.
5855
5856 template<int size, bool big_endian>
5857 void
5858 Mips_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
5859 {
5860   // Call parent class to read symbol information.
5861   this->base_read_symbols(sd);
5862
5863   // Read processor-specific flags in ELF file header.
5864   const unsigned char* pehdr = this->get_view(elfcpp::file_header_offset,
5865                                             elfcpp::Elf_sizes<size>::ehdr_size,
5866                                             true, false);
5867   elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
5868   this->processor_specific_flags_ = ehdr.get_e_flags();
5869
5870   // Get the section names.
5871   const unsigned char* pnamesu = sd->section_names->data();
5872   const char* pnames = reinterpret_cast<const char*>(pnamesu);
5873
5874   // Initialize the mips16 stub section bit-vectors.
5875   this->section_is_mips16_fn_stub_.resize(this->shnum(), false);
5876   this->section_is_mips16_call_stub_.resize(this->shnum(), false);
5877   this->section_is_mips16_call_fp_stub_.resize(this->shnum(), false);
5878
5879   const size_t shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
5880   const unsigned char* pshdrs = sd->section_headers->data();
5881   const unsigned char* ps = pshdrs + shdr_size;
5882   for (unsigned int i = 1; i < this->shnum(); ++i, ps += shdr_size)
5883     {
5884       elfcpp::Shdr<size, big_endian> shdr(ps);
5885
5886       if (shdr.get_sh_type() == elfcpp::SHT_MIPS_REGINFO)
5887         {
5888           // Read the gp value that was used to create this object.  We need the
5889           // gp value while processing relocs.  The .reginfo section is not used
5890           // in the 64-bit MIPS ELF ABI.
5891           section_offset_type section_offset = shdr.get_sh_offset();
5892           section_size_type section_size =
5893             convert_to_section_size_type(shdr.get_sh_size());
5894           const unsigned char* view =
5895              this->get_view(section_offset, section_size, true, false);
5896
5897           this->gp_ = elfcpp::Swap<size, big_endian>::readval(view + 20);
5898
5899           // Read the rest of .reginfo.
5900           this->gprmask_ = elfcpp::Swap<size, big_endian>::readval(view);
5901           this->cprmask1_ = elfcpp::Swap<size, big_endian>::readval(view + 4);
5902           this->cprmask2_ = elfcpp::Swap<size, big_endian>::readval(view + 8);
5903           this->cprmask3_ = elfcpp::Swap<size, big_endian>::readval(view + 12);
5904           this->cprmask4_ = elfcpp::Swap<size, big_endian>::readval(view + 16);
5905         }
5906
5907       const char* name = pnames + shdr.get_sh_name();
5908       this->section_is_mips16_fn_stub_[i] = is_prefix_of(".mips16.fn", name);
5909       this->section_is_mips16_call_stub_[i] =
5910         is_prefix_of(".mips16.call.", name);
5911       this->section_is_mips16_call_fp_stub_[i] =
5912         is_prefix_of(".mips16.call.fp.", name);
5913
5914       if (strcmp(name, ".pdr") == 0)
5915         {
5916           gold_assert(this->pdr_shndx_ == -1U);
5917           this->pdr_shndx_ = i;
5918         }
5919     }
5920 }
5921
5922 // Discard MIPS16 stub secions that are not needed.
5923
5924 template<int size, bool big_endian>
5925 void
5926 Mips_relobj<size, big_endian>::discard_mips16_stub_sections(Symbol_table* symtab)
5927 {
5928   for (typename Mips16_stubs_int_map::const_iterator
5929        it = this->mips16_stub_sections_.begin();
5930        it != this->mips16_stub_sections_.end(); ++it)
5931     {
5932       Mips16_stub_section<size, big_endian>* stub_section = it->second;
5933       if (!stub_section->is_target_found())
5934         {
5935           gold_error(_("no relocation found in mips16 stub section '%s'"),
5936                      stub_section->object()
5937                        ->section_name(stub_section->shndx()).c_str());
5938         }
5939
5940       bool discard = false;
5941       if (stub_section->is_for_local_function())
5942         {
5943           if (stub_section->is_fn_stub())
5944             {
5945               // This stub is for a local symbol.  This stub will only
5946               // be needed if there is some relocation in this object,
5947               // other than a 16 bit function call, which refers to this
5948               // symbol.
5949               if (!this->has_local_non_16bit_call_relocs(stub_section->r_sym()))
5950                 discard = true;
5951               else
5952                 this->add_local_mips16_fn_stub(stub_section);
5953             }
5954           else
5955             {
5956               // This stub is for a local symbol.  This stub will only
5957               // be needed if there is some relocation (R_MIPS16_26) in
5958               // this object that refers to this symbol.
5959               gold_assert(stub_section->is_call_stub()
5960                           || stub_section->is_call_fp_stub());
5961               if (!this->has_local_16bit_call_relocs(stub_section->r_sym()))
5962                 discard = true;
5963               else
5964                 this->add_local_mips16_call_stub(stub_section);
5965             }
5966         }
5967       else
5968         {
5969           Mips_symbol<size>* gsym = stub_section->gsym();
5970           if (stub_section->is_fn_stub())
5971             {
5972               if (gsym->has_mips16_fn_stub())
5973                 // We already have a stub for this function.
5974                 discard = true;
5975               else
5976                 {
5977                   gsym->set_mips16_fn_stub(stub_section);
5978                   if (gsym->should_add_dynsym_entry(symtab))
5979                     {
5980                       // If we have a MIPS16 function with a stub, the
5981                       // dynamic symbol must refer to the stub, since only
5982                       // the stub uses the standard calling conventions.
5983                       gsym->set_need_fn_stub();
5984                       if (gsym->is_from_dynobj())
5985                         gsym->set_needs_dynsym_value();
5986                     }
5987                 }
5988               if (!gsym->need_fn_stub())
5989                 discard = true;
5990             }
5991           else if (stub_section->is_call_stub())
5992             {
5993               if (gsym->is_mips16())
5994                 // We don't need the call_stub; this is a 16 bit
5995                 // function, so calls from other 16 bit functions are
5996                 // OK.
5997                 discard = true;
5998               else if (gsym->has_mips16_call_stub())
5999                 // We already have a stub for this function.
6000                 discard = true;
6001               else
6002                 gsym->set_mips16_call_stub(stub_section);
6003             }
6004           else
6005             {
6006               gold_assert(stub_section->is_call_fp_stub());
6007               if (gsym->is_mips16())
6008                 // We don't need the call_stub; this is a 16 bit
6009                 // function, so calls from other 16 bit functions are
6010                 // OK.
6011                 discard = true;
6012               else if (gsym->has_mips16_call_fp_stub())
6013                 // We already have a stub for this function.
6014                 discard = true;
6015               else
6016                 gsym->set_mips16_call_fp_stub(stub_section);
6017             }
6018         }
6019       if (discard)
6020         this->set_output_section(stub_section->shndx(), NULL);
6021    }
6022 }
6023
6024 // Mips_output_data_la25_stub methods.
6025
6026 // Template for standard LA25 stub.
6027 template<int size, bool big_endian>
6028 const uint32_t
6029 Mips_output_data_la25_stub<size, big_endian>::la25_stub_entry[] =
6030 {
6031   0x3c190000,           // lui $25,%hi(func)
6032   0x08000000,           // j func
6033   0x27390000,           // add $25,$25,%lo(func)
6034   0x00000000            // nop
6035 };
6036
6037 // Template for microMIPS LA25 stub.
6038 template<int size, bool big_endian>
6039 const uint32_t
6040 Mips_output_data_la25_stub<size, big_endian>::la25_stub_micromips_entry[] =
6041 {
6042   0x41b9, 0x0000,       // lui t9,%hi(func)
6043   0xd400, 0x0000,       // j func
6044   0x3339, 0x0000,       // addiu t9,t9,%lo(func)
6045   0x0000, 0x0000        // nop
6046 };
6047
6048 // Create la25 stub for a symbol.
6049
6050 template<int size, bool big_endian>
6051 void
6052 Mips_output_data_la25_stub<size, big_endian>::create_la25_stub(
6053     Symbol_table* symtab, Target_mips<size, big_endian>* target,
6054     Mips_symbol<size>* gsym)
6055 {
6056   if (!gsym->has_la25_stub())
6057     {
6058       gsym->set_la25_stub_offset(this->symbols_.size() * 16);
6059       this->symbols_.insert(gsym);
6060       this->create_stub_symbol(gsym, symtab, target, 16);
6061     }
6062 }
6063
6064 // Create a symbol for SYM stub's value and size, to help make the disassembly
6065 // easier to read.
6066
6067 template<int size, bool big_endian>
6068 void
6069 Mips_output_data_la25_stub<size, big_endian>::create_stub_symbol(
6070     Mips_symbol<size>* sym, Symbol_table* symtab,
6071     Target_mips<size, big_endian>* target, uint64_t symsize)
6072 {
6073   std::string name(".pic.");
6074   name += sym->name();
6075
6076   unsigned int offset = sym->la25_stub_offset();
6077   if (sym->is_micromips())
6078     offset |= 1;
6079
6080   // Make it a local function.
6081   Symbol* new_sym = symtab->define_in_output_data(name.c_str(), NULL,
6082                                       Symbol_table::PREDEFINED,
6083                                       target->la25_stub_section(),
6084                                       offset, symsize, elfcpp::STT_FUNC,
6085                                       elfcpp::STB_LOCAL,
6086                                       elfcpp::STV_DEFAULT, 0,
6087                                       false, false);
6088   new_sym->set_is_forced_local();
6089 }
6090
6091 // Write out la25 stubs.  This uses the hand-coded instructions above,
6092 // and adjusts them as needed.
6093
6094 template<int size, bool big_endian>
6095 void
6096 Mips_output_data_la25_stub<size, big_endian>::do_write(Output_file* of)
6097 {
6098   const off_t offset = this->offset();
6099   const section_size_type oview_size =
6100     convert_to_section_size_type(this->data_size());
6101   unsigned char* const oview = of->get_output_view(offset, oview_size);
6102
6103   for (typename Unordered_set<Mips_symbol<size>*>::iterator
6104        p = this->symbols_.begin();
6105        p != this->symbols_.end();
6106        ++p)
6107     {
6108       Mips_symbol<size>* sym = *p;
6109       unsigned char* pov = oview + sym->la25_stub_offset();
6110
6111       Mips_address target = sym->value();
6112       if (!sym->is_micromips())
6113         {
6114           elfcpp::Swap<32, big_endian>::writeval(pov,
6115               la25_stub_entry[0] | (((target + 0x8000) >> 16) & 0xffff));
6116           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6117               la25_stub_entry[1] | ((target >> 2) & 0x3ffffff));
6118           elfcpp::Swap<32, big_endian>::writeval(pov + 8,
6119               la25_stub_entry[2] | (target & 0xffff));
6120           elfcpp::Swap<32, big_endian>::writeval(pov + 12, la25_stub_entry[3]);
6121         }
6122       else
6123         {
6124           target |= 1;
6125           // First stub instruction.  Paste high 16-bits of the target.
6126           elfcpp::Swap<16, big_endian>::writeval(pov,
6127                                                  la25_stub_micromips_entry[0]);
6128           elfcpp::Swap<16, big_endian>::writeval(pov + 2,
6129               ((target + 0x8000) >> 16) & 0xffff);
6130           // Second stub instruction.  Paste low 26-bits of the target, shifted
6131           // right by 1.
6132           elfcpp::Swap<16, big_endian>::writeval(pov + 4,
6133               la25_stub_micromips_entry[2] | ((target >> 17) & 0x3ff));
6134           elfcpp::Swap<16, big_endian>::writeval(pov + 6,
6135               la25_stub_micromips_entry[3] | ((target >> 1) & 0xffff));
6136           // Third stub instruction.  Paste low 16-bits of the target.
6137           elfcpp::Swap<16, big_endian>::writeval(pov + 8,
6138                                                  la25_stub_micromips_entry[4]);
6139           elfcpp::Swap<16, big_endian>::writeval(pov + 10, target & 0xffff);
6140           // Fourth stub instruction.
6141           elfcpp::Swap<16, big_endian>::writeval(pov + 12,
6142                                                  la25_stub_micromips_entry[6]);
6143           elfcpp::Swap<16, big_endian>::writeval(pov + 14,
6144                                                  la25_stub_micromips_entry[7]);
6145         }
6146     }
6147
6148   of->write_output_view(offset, oview_size, oview);
6149 }
6150
6151 // Mips_output_data_plt methods.
6152
6153 // The format of the first PLT entry in an O32 executable.
6154 template<int size, bool big_endian>
6155 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_o32[] =
6156 {
6157   0x3c1c0000,         // lui $28, %hi(&GOTPLT[0])
6158   0x8f990000,         // lw $25, %lo(&GOTPLT[0])($28)
6159   0x279c0000,         // addiu $28, $28, %lo(&GOTPLT[0])
6160   0x031cc023,         // subu $24, $24, $28
6161   0x03e07821,         // move $15, $31        # 32-bit move (addu)
6162   0x0018c082,         // srl $24, $24, 2
6163   0x0320f809,         // jalr $25
6164   0x2718fffe          // subu $24, $24, 2
6165 };
6166
6167 // The format of the first PLT entry in an N32 executable.  Different
6168 // because gp ($28) is not available; we use t2 ($14) instead.
6169 template<int size, bool big_endian>
6170 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n32[] =
6171 {
6172   0x3c0e0000,         // lui $14, %hi(&GOTPLT[0])
6173   0x8dd90000,         // lw $25, %lo(&GOTPLT[0])($14)
6174   0x25ce0000,         // addiu $14, $14, %lo(&GOTPLT[0])
6175   0x030ec023,         // subu $24, $24, $14
6176   0x03e07821,         // move $15, $31        # 32-bit move (addu)
6177   0x0018c082,         // srl $24, $24, 2
6178   0x0320f809,         // jalr $25
6179   0x2718fffe          // subu $24, $24, 2
6180 };
6181
6182 // The format of the first PLT entry in an N64 executable.  Different
6183 // from N32 because of the increased size of GOT entries.
6184 template<int size, bool big_endian>
6185 const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n64[] =
6186 {
6187   0x3c0e0000,         // lui $14, %hi(&GOTPLT[0])
6188   0xddd90000,         // ld $25, %lo(&GOTPLT[0])($14)
6189   0x25ce0000,         // addiu $14, $14, %lo(&GOTPLT[0])
6190   0x030ec023,         // subu $24, $24, $14
6191   0x03e07821,         // move $15, $31        # 64-bit move (daddu)
6192   0x0018c0c2,         // srl $24, $24, 3
6193   0x0320f809,         // jalr $25
6194   0x2718fffe          // subu $24, $24, 2
6195 };
6196
6197 // The format of the microMIPS first PLT entry in an O32 executable.
6198 // We rely on v0 ($2) rather than t8 ($24) to contain the address
6199 // of the GOTPLT entry handled, so this stub may only be used when
6200 // all the subsequent PLT entries are microMIPS code too.
6201 //
6202 // The trailing NOP is for alignment and correct disassembly only.
6203 template<int size, bool big_endian>
6204 const uint32_t Mips_output_data_plt<size, big_endian>::
6205 plt0_entry_micromips_o32[] =
6206 {
6207   0x7980, 0x0000,      // addiupc $3, (&GOTPLT[0]) - .
6208   0xff23, 0x0000,      // lw $25, 0($3)
6209   0x0535,              // subu $2, $2, $3
6210   0x2525,              // srl $2, $2, 2
6211   0x3302, 0xfffe,      // subu $24, $2, 2
6212   0x0dff,              // move $15, $31
6213   0x45f9,              // jalrs $25
6214   0x0f83,              // move $28, $3
6215   0x0c00               // nop
6216 };
6217
6218 // The format of the microMIPS first PLT entry in an O32 executable
6219 // in the insn32 mode.
6220 template<int size, bool big_endian>
6221 const uint32_t Mips_output_data_plt<size, big_endian>::
6222 plt0_entry_micromips32_o32[] =
6223 {
6224   0x41bc, 0x0000,      // lui $28, %hi(&GOTPLT[0])
6225   0xff3c, 0x0000,      // lw $25, %lo(&GOTPLT[0])($28)
6226   0x339c, 0x0000,      // addiu $28, $28, %lo(&GOTPLT[0])
6227   0x0398, 0xc1d0,      // subu $24, $24, $28
6228   0x001f, 0x7950,      // move $15, $31
6229   0x0318, 0x1040,      // srl $24, $24, 2
6230   0x03f9, 0x0f3c,      // jalr $25
6231   0x3318, 0xfffe       // subu $24, $24, 2
6232 };
6233
6234 // The format of subsequent standard entries in the PLT.
6235 template<int size, bool big_endian>
6236 const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry[] =
6237 {
6238   0x3c0f0000,           // lui $15, %hi(.got.plt entry)
6239   0x8df90000,           // l[wd] $25, %lo(.got.plt entry)($15)
6240   0x03200008,           // jr $25
6241   0x25f80000            // addiu $24, $15, %lo(.got.plt entry)
6242 };
6243
6244 // The format of subsequent MIPS16 o32 PLT entries.  We use v1 ($3) as a
6245 // temporary because t8 ($24) and t9 ($25) are not directly addressable.
6246 // Note that this differs from the GNU ld which uses both v0 ($2) and v1 ($3).
6247 // We cannot use v0 because MIPS16 call stubs from the CS toolchain expect
6248 // target function address in register v0.
6249 template<int size, bool big_endian>
6250 const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry_mips16_o32[] =
6251 {
6252   0xb303,              // lw $3, 12($pc)
6253   0x651b,              // move $24, $3
6254   0x9b60,              // lw $3, 0($3)
6255   0xeb00,              // jr $3
6256   0x653b,              // move $25, $3
6257   0x6500,              // nop
6258   0x0000, 0x0000       // .word (.got.plt entry)
6259 };
6260
6261 // The format of subsequent microMIPS o32 PLT entries.  We use v0 ($2)
6262 // as a temporary because t8 ($24) is not addressable with ADDIUPC.
6263 template<int size, bool big_endian>
6264 const uint32_t Mips_output_data_plt<size, big_endian>::
6265 plt_entry_micromips_o32[] =
6266 {
6267   0x7900, 0x0000,      // addiupc $2, (.got.plt entry) - .
6268   0xff22, 0x0000,      // lw $25, 0($2)
6269   0x4599,              // jr $25
6270   0x0f02               // move $24, $2
6271 };
6272
6273 // The format of subsequent microMIPS o32 PLT entries in the insn32 mode.
6274 template<int size, bool big_endian>
6275 const uint32_t Mips_output_data_plt<size, big_endian>::
6276 plt_entry_micromips32_o32[] =
6277 {
6278   0x41af, 0x0000,      // lui $15, %hi(.got.plt entry)
6279   0xff2f, 0x0000,      // lw $25, %lo(.got.plt entry)($15)
6280   0x0019, 0x0f3c,      // jr $25
6281   0x330f, 0x0000       // addiu $24, $15, %lo(.got.plt entry)
6282 };
6283
6284 // Add an entry to the PLT for a symbol referenced by r_type relocation.
6285
6286 template<int size, bool big_endian>
6287 void
6288 Mips_output_data_plt<size, big_endian>::add_entry(Mips_symbol<size>* gsym,
6289                                                   unsigned int r_type)
6290 {
6291   gold_assert(!gsym->has_plt_offset());
6292
6293   // Final PLT offset for a symbol will be set in method set_plt_offsets().
6294   gsym->set_plt_offset(this->entry_count() * sizeof(plt_entry)
6295                        + sizeof(plt0_entry_o32));
6296   this->symbols_.push_back(gsym);
6297
6298   // Record whether the relocation requires a standard MIPS
6299   // or a compressed code entry.
6300   if (jal_reloc(r_type))
6301    {
6302      if (r_type == elfcpp::R_MIPS_26)
6303        gsym->set_needs_mips_plt(true);
6304      else
6305        gsym->set_needs_comp_plt(true);
6306    }
6307
6308   section_offset_type got_offset = this->got_plt_->current_data_size();
6309
6310   // Every PLT entry needs a GOT entry which points back to the PLT
6311   // entry (this will be changed by the dynamic linker, normally
6312   // lazily when the function is called).
6313   this->got_plt_->set_current_data_size(got_offset + size/8);
6314
6315   gsym->set_needs_dynsym_entry();
6316   this->rel_->add_global(gsym, elfcpp::R_MIPS_JUMP_SLOT, this->got_plt_,
6317                          got_offset);
6318 }
6319
6320 // Set final PLT offsets.  For each symbol, determine whether standard or
6321 // compressed (MIPS16 or microMIPS) PLT entry is used.
6322
6323 template<int size, bool big_endian>
6324 void
6325 Mips_output_data_plt<size, big_endian>::set_plt_offsets()
6326 {
6327   // The sizes of individual PLT entries.
6328   unsigned int plt_mips_entry_size = this->standard_plt_entry_size();
6329   unsigned int plt_comp_entry_size = (!this->target_->is_output_newabi()
6330                                       ? this->compressed_plt_entry_size() : 0);
6331
6332   for (typename std::vector<Mips_symbol<size>*>::const_iterator
6333        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6334     {
6335       Mips_symbol<size>* mips_sym = *p;
6336
6337       // There are no defined MIPS16 or microMIPS PLT entries for n32 or n64,
6338       // so always use a standard entry there.
6339       //
6340       // If the symbol has a MIPS16 call stub and gets a PLT entry, then
6341       // all MIPS16 calls will go via that stub, and there is no benefit
6342       // to having a MIPS16 entry.  And in the case of call_stub a
6343       // standard entry actually has to be used as the stub ends with a J
6344       // instruction.
6345       if (this->target_->is_output_newabi()
6346           || mips_sym->has_mips16_call_stub()
6347           || mips_sym->has_mips16_call_fp_stub())
6348         {
6349           mips_sym->set_needs_mips_plt(true);
6350           mips_sym->set_needs_comp_plt(false);
6351         }
6352
6353       // Otherwise, if there are no direct calls to the function, we
6354       // have a free choice of whether to use standard or compressed
6355       // entries.  Prefer microMIPS entries if the object is known to
6356       // contain microMIPS code, so that it becomes possible to create
6357       // pure microMIPS binaries.  Prefer standard entries otherwise,
6358       // because MIPS16 ones are no smaller and are usually slower.
6359       if (!mips_sym->needs_mips_plt() && !mips_sym->needs_comp_plt())
6360         {
6361           if (this->target_->is_output_micromips())
6362             mips_sym->set_needs_comp_plt(true);
6363           else
6364             mips_sym->set_needs_mips_plt(true);
6365         }
6366
6367       if (mips_sym->needs_mips_plt())
6368         {
6369           mips_sym->set_mips_plt_offset(this->plt_mips_offset_);
6370           this->plt_mips_offset_ += plt_mips_entry_size;
6371         }
6372       if (mips_sym->needs_comp_plt())
6373         {
6374           mips_sym->set_comp_plt_offset(this->plt_comp_offset_);
6375           this->plt_comp_offset_ += plt_comp_entry_size;
6376         }
6377     }
6378
6379     // Figure out the size of the PLT header if we know that we are using it.
6380     if (this->plt_mips_offset_ + this->plt_comp_offset_ != 0)
6381       this->plt_header_size_ = this->get_plt_header_size();
6382 }
6383
6384 // Write out the PLT.  This uses the hand-coded instructions above,
6385 // and adjusts them as needed.
6386
6387 template<int size, bool big_endian>
6388 void
6389 Mips_output_data_plt<size, big_endian>::do_write(Output_file* of)
6390 {
6391   const off_t offset = this->offset();
6392   const section_size_type oview_size =
6393     convert_to_section_size_type(this->data_size());
6394   unsigned char* const oview = of->get_output_view(offset, oview_size);
6395
6396   const off_t gotplt_file_offset = this->got_plt_->offset();
6397   const section_size_type gotplt_size =
6398     convert_to_section_size_type(this->got_plt_->data_size());
6399   unsigned char* const gotplt_view = of->get_output_view(gotplt_file_offset,
6400                                                          gotplt_size);
6401   unsigned char* pov = oview;
6402
6403   Mips_address plt_address = this->address();
6404
6405   // Calculate the address of .got.plt.
6406   Mips_address gotplt_addr = this->got_plt_->address();
6407   Mips_address gotplt_addr_high = ((gotplt_addr + 0x8000) >> 16) & 0xffff;
6408   Mips_address gotplt_addr_low = gotplt_addr & 0xffff;
6409
6410   // The PLT sequence is not safe for N64 if .got.plt's address can
6411   // not be loaded in two instructions.
6412   gold_assert((gotplt_addr & ~(Mips_address) 0x7fffffff) == 0
6413               || ~(gotplt_addr | 0x7fffffff) == 0);
6414
6415   // Write the PLT header.
6416   const uint32_t* plt0_entry = this->get_plt_header_entry();
6417   if (plt0_entry == plt0_entry_micromips_o32)
6418     {
6419       // Write microMIPS PLT header.
6420       gold_assert(gotplt_addr % 4 == 0);
6421
6422       Mips_address gotpc_offset = gotplt_addr - ((plt_address | 3) ^ 3);
6423
6424       // ADDIUPC has a span of +/-16MB, check we're in range.
6425       if (gotpc_offset + 0x1000000 >= 0x2000000)
6426        {
6427          gold_error(_(".got.plt offset of %ld from .plt beyond the range of "
6428                     "ADDIUPC"), (long)gotpc_offset);
6429          return;
6430        }
6431
6432       elfcpp::Swap<16, big_endian>::writeval(pov,
6433                  plt0_entry[0] | ((gotpc_offset >> 18) & 0x7f));
6434       elfcpp::Swap<16, big_endian>::writeval(pov + 2,
6435                                              (gotpc_offset >> 2) & 0xffff);
6436       pov += 4;
6437       for (unsigned int i = 2;
6438            i < (sizeof(plt0_entry_micromips_o32)
6439                 / sizeof(plt0_entry_micromips_o32[0]));
6440            i++)
6441         {
6442           elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]);
6443           pov += 2;
6444         }
6445     }
6446   else if (plt0_entry == plt0_entry_micromips32_o32)
6447     {
6448       // Write microMIPS PLT header in insn32 mode.
6449       elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[0]);
6450       elfcpp::Swap<16, big_endian>::writeval(pov + 2, gotplt_addr_high);
6451       elfcpp::Swap<16, big_endian>::writeval(pov + 4, plt0_entry[2]);
6452       elfcpp::Swap<16, big_endian>::writeval(pov + 6, gotplt_addr_low);
6453       elfcpp::Swap<16, big_endian>::writeval(pov + 8, plt0_entry[4]);
6454       elfcpp::Swap<16, big_endian>::writeval(pov + 10, gotplt_addr_low);
6455       pov += 12;
6456       for (unsigned int i = 6;
6457            i < (sizeof(plt0_entry_micromips32_o32)
6458                 / sizeof(plt0_entry_micromips32_o32[0]));
6459            i++)
6460         {
6461           elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]);
6462           pov += 2;
6463         }
6464     }
6465   else
6466     {
6467       // Write standard PLT header.
6468       elfcpp::Swap<32, big_endian>::writeval(pov,
6469                                              plt0_entry[0] | gotplt_addr_high);
6470       elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6471                                              plt0_entry[1] | gotplt_addr_low);
6472       elfcpp::Swap<32, big_endian>::writeval(pov + 8,
6473                                              plt0_entry[2] | gotplt_addr_low);
6474       pov += 12;
6475       for (int i = 3; i < 8; i++)
6476         {
6477           elfcpp::Swap<32, big_endian>::writeval(pov, plt0_entry[i]);
6478           pov += 4;
6479         }
6480     }
6481
6482
6483   unsigned char* gotplt_pov = gotplt_view;
6484   unsigned int got_entry_size = size/8; // TODO(sasa): MIPS_ELF_GOT_SIZE
6485
6486   // The first two entries in .got.plt are reserved.
6487   elfcpp::Swap<size, big_endian>::writeval(gotplt_pov, 0);
6488   elfcpp::Swap<size, big_endian>::writeval(gotplt_pov + got_entry_size, 0);
6489
6490   unsigned int gotplt_offset = 2 * got_entry_size;
6491   gotplt_pov += 2 * got_entry_size;
6492
6493   // Calculate the address of the PLT header.
6494   Mips_address header_address = (plt_address
6495                                  + (this->is_plt_header_compressed() ? 1 : 0));
6496
6497   // Initialize compressed PLT area view.
6498   unsigned char* pov2 = pov + this->plt_mips_offset_;
6499
6500   // Write the PLT entries.
6501   for (typename std::vector<Mips_symbol<size>*>::const_iterator
6502        p = this->symbols_.begin();
6503        p != this->symbols_.end();
6504        ++p, gotplt_pov += got_entry_size, gotplt_offset += got_entry_size)
6505     {
6506       Mips_symbol<size>* mips_sym = *p;
6507
6508       // Calculate the address of the .got.plt entry.
6509       uint32_t gotplt_entry_addr = (gotplt_addr + gotplt_offset);
6510       uint32_t gotplt_entry_addr_hi = (((gotplt_entry_addr + 0x8000) >> 16)
6511                                        & 0xffff);
6512       uint32_t gotplt_entry_addr_lo = gotplt_entry_addr & 0xffff;
6513
6514       // Initially point the .got.plt entry at the PLT header.
6515       if (this->target_->is_output_n64())
6516         elfcpp::Swap<64, big_endian>::writeval(gotplt_pov, header_address);
6517       else
6518         elfcpp::Swap<32, big_endian>::writeval(gotplt_pov, header_address);
6519
6520       // Now handle the PLT itself.  First the standard entry.
6521       if (mips_sym->has_mips_plt_offset())
6522         {
6523           // Pick the load opcode (LW or LD).
6524           uint64_t load = this->target_->is_output_n64() ? 0xdc000000
6525                                                          : 0x8c000000;
6526
6527           // Fill in the PLT entry itself.
6528           elfcpp::Swap<32, big_endian>::writeval(pov,
6529               plt_entry[0] | gotplt_entry_addr_hi);
6530           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6531               plt_entry[1] | gotplt_entry_addr_lo | load);
6532           elfcpp::Swap<32, big_endian>::writeval(pov + 8, plt_entry[2]);
6533           elfcpp::Swap<32, big_endian>::writeval(pov + 12,
6534               plt_entry[3] | gotplt_entry_addr_lo);
6535           pov += 16;
6536         }
6537
6538       // Now the compressed entry.  They come after any standard ones.
6539       if (mips_sym->has_comp_plt_offset())
6540         {
6541           if (!this->target_->is_output_micromips())
6542             {
6543               // Write MIPS16 PLT entry.
6544               const uint32_t* plt_entry = plt_entry_mips16_o32;
6545
6546               elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]);
6547               elfcpp::Swap<16, big_endian>::writeval(pov2 + 2, plt_entry[1]);
6548               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6549               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]);
6550               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6551               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6552               elfcpp::Swap<32, big_endian>::writeval(pov2 + 12,
6553                                                      gotplt_entry_addr);
6554               pov2 += 16;
6555             }
6556           else if (this->target_->use_32bit_micromips_instructions())
6557             {
6558               // Write microMIPS PLT entry in insn32 mode.
6559               const uint32_t* plt_entry = plt_entry_micromips32_o32;
6560
6561               elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]);
6562               elfcpp::Swap<16, big_endian>::writeval(pov2 + 2,
6563                                                      gotplt_entry_addr_hi);
6564               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6565               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6,
6566                                                      gotplt_entry_addr_lo);
6567               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6568               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6569               elfcpp::Swap<16, big_endian>::writeval(pov2 + 12, plt_entry[6]);
6570               elfcpp::Swap<16, big_endian>::writeval(pov2 + 14,
6571                                                      gotplt_entry_addr_lo);
6572               pov2 += 16;
6573             }
6574           else
6575             {
6576               // Write microMIPS PLT entry.
6577               const uint32_t* plt_entry = plt_entry_micromips_o32;
6578
6579               gold_assert(gotplt_entry_addr % 4 == 0);
6580
6581               Mips_address loc_address = plt_address + pov2 - oview;
6582               int gotpc_offset = gotplt_entry_addr - ((loc_address | 3) ^ 3);
6583
6584               // ADDIUPC has a span of +/-16MB, check we're in range.
6585               if (gotpc_offset + 0x1000000 >= 0x2000000)
6586                 {
6587                   gold_error(_(".got.plt offset of %ld from .plt beyond the "
6588                              "range of ADDIUPC"), (long)gotpc_offset);
6589                   return;
6590                 }
6591
6592               elfcpp::Swap<16, big_endian>::writeval(pov2,
6593                           plt_entry[0] | ((gotpc_offset >> 18) & 0x7f));
6594               elfcpp::Swap<16, big_endian>::writeval(
6595                   pov2 + 2, (gotpc_offset >> 2) & 0xffff);
6596               elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]);
6597               elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]);
6598               elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]);
6599               elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]);
6600               pov2 += 12;
6601             }
6602         }
6603     }
6604
6605   // Check the number of bytes written for standard entries.
6606   gold_assert(static_cast<section_size_type>(
6607       pov - oview - this->plt_header_size_) == this->plt_mips_offset_);
6608   // Check the number of bytes written for compressed entries.
6609   gold_assert((static_cast<section_size_type>(pov2 - pov)
6610                == this->plt_comp_offset_));
6611   // Check the total number of bytes written.
6612   gold_assert(static_cast<section_size_type>(pov2 - oview) == oview_size);
6613
6614   gold_assert(static_cast<section_size_type>(gotplt_pov - gotplt_view)
6615               == gotplt_size);
6616
6617   of->write_output_view(offset, oview_size, oview);
6618   of->write_output_view(gotplt_file_offset, gotplt_size, gotplt_view);
6619 }
6620
6621 // Mips_output_data_mips_stubs methods.
6622
6623 // The format of the lazy binding stub when dynamic symbol count is less than
6624 // 64K, dynamic symbol index is less than 32K, and ABI is not N64.
6625 template<int size, bool big_endian>
6626 const uint32_t
6627 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1[4] =
6628 {
6629   0x8f998010,         // lw t9,0x8010(gp)
6630   0x03e07821,         // addu t7,ra,zero
6631   0x0320f809,         // jalr t9,ra
6632   0x24180000          // addiu t8,zero,DYN_INDEX sign extended
6633 };
6634
6635 // The format of the lazy binding stub when dynamic symbol count is less than
6636 // 64K, dynamic symbol index is less than 32K, and ABI is N64.
6637 template<int size, bool big_endian>
6638 const uint32_t
6639 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1_n64[4] =
6640 {
6641   0xdf998010,         // ld t9,0x8010(gp)
6642   0x03e0782d,         // daddu t7,ra,zero
6643   0x0320f809,         // jalr t9,ra
6644   0x64180000          // daddiu t8,zero,DYN_INDEX sign extended
6645 };
6646
6647 // The format of the lazy binding stub when dynamic symbol count is less than
6648 // 64K, dynamic symbol index is between 32K and 64K, and ABI is not N64.
6649 template<int size, bool big_endian>
6650 const uint32_t
6651 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2[4] =
6652 {
6653   0x8f998010,         // lw t9,0x8010(gp)
6654   0x03e07821,         // addu t7,ra,zero
6655   0x0320f809,         // jalr t9,ra
6656   0x34180000          // ori t8,zero,DYN_INDEX unsigned
6657 };
6658
6659 // The format of the lazy binding stub when dynamic symbol count is less than
6660 // 64K, dynamic symbol index is between 32K and 64K, and ABI is N64.
6661 template<int size, bool big_endian>
6662 const uint32_t
6663 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2_n64[4] =
6664 {
6665   0xdf998010,         // ld t9,0x8010(gp)
6666   0x03e0782d,         // daddu t7,ra,zero
6667   0x0320f809,         // jalr t9,ra
6668   0x34180000          // ori t8,zero,DYN_INDEX unsigned
6669 };
6670
6671 // The format of the lazy binding stub when dynamic symbol count is greater than
6672 // 64K, and ABI is not N64.
6673 template<int size, bool big_endian>
6674 const uint32_t Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big[5] =
6675 {
6676   0x8f998010,         // lw t9,0x8010(gp)
6677   0x03e07821,         // addu t7,ra,zero
6678   0x3c180000,         // lui t8,DYN_INDEX
6679   0x0320f809,         // jalr t9,ra
6680   0x37180000          // ori t8,t8,DYN_INDEX
6681 };
6682
6683 // The format of the lazy binding stub when dynamic symbol count is greater than
6684 // 64K, and ABI is N64.
6685 template<int size, bool big_endian>
6686 const uint32_t
6687 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big_n64[5] =
6688 {
6689   0xdf998010,         // ld t9,0x8010(gp)
6690   0x03e0782d,         // daddu t7,ra,zero
6691   0x3c180000,         // lui t8,DYN_INDEX
6692   0x0320f809,         // jalr t9,ra
6693   0x37180000          // ori t8,t8,DYN_INDEX
6694 };
6695
6696 // microMIPS stubs.
6697
6698 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6699 // less than 64K, dynamic symbol index is less than 32K, and ABI is not N64.
6700 template<int size, bool big_endian>
6701 const uint32_t
6702 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_1[] =
6703 {
6704   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6705   0x0dff,             // move t7,ra
6706   0x45d9,             // jalr t9
6707   0x3300, 0x0000      // addiu t8,zero,DYN_INDEX sign extended
6708 };
6709
6710 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6711 // less than 64K, dynamic symbol index is less than 32K, and ABI is N64.
6712 template<int size, bool big_endian>
6713 const uint32_t
6714 Mips_output_data_mips_stubs<size, big_endian>::
6715 lazy_stub_micromips_normal_1_n64[] =
6716 {
6717   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6718   0x0dff,             // move t7,ra
6719   0x45d9,             // jalr t9
6720   0x5f00, 0x0000      // daddiu t8,zero,DYN_INDEX sign extended
6721 };
6722
6723 // The format of the microMIPS lazy binding stub when dynamic symbol
6724 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6725 // and ABI is not N64.
6726 template<int size, bool big_endian>
6727 const uint32_t
6728 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_2[] =
6729 {
6730   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6731   0x0dff,             // move t7,ra
6732   0x45d9,             // jalr t9
6733   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6734 };
6735
6736 // The format of the microMIPS lazy binding stub when dynamic symbol
6737 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6738 // and ABI is N64.
6739 template<int size, bool big_endian>
6740 const uint32_t
6741 Mips_output_data_mips_stubs<size, big_endian>::
6742 lazy_stub_micromips_normal_2_n64[] =
6743 {
6744   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6745   0x0dff,             // move t7,ra
6746   0x45d9,             // jalr t9
6747   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6748 };
6749
6750 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6751 // greater than 64K, and ABI is not N64.
6752 template<int size, bool big_endian>
6753 const uint32_t
6754 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big[] =
6755 {
6756   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6757   0x0dff,             // move t7,ra
6758   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6759   0x45d9,             // jalr t9
6760   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6761 };
6762
6763 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6764 // greater than 64K, and ABI is N64.
6765 template<int size, bool big_endian>
6766 const uint32_t
6767 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big_n64[] =
6768 {
6769   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6770   0x0dff,             // move t7,ra
6771   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6772   0x45d9,             // jalr t9
6773   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6774 };
6775
6776 // 32-bit microMIPS stubs.
6777
6778 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6779 // less than 64K, dynamic symbol index is less than 32K, ABI is not N64, and we
6780 // can use only 32-bit instructions.
6781 template<int size, bool big_endian>
6782 const uint32_t
6783 Mips_output_data_mips_stubs<size, big_endian>::
6784 lazy_stub_micromips32_normal_1[] =
6785 {
6786   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6787   0x001f, 0x7950,     // addu t7,ra,zero
6788   0x03f9, 0x0f3c,     // jalr ra,t9
6789   0x3300, 0x0000      // addiu t8,zero,DYN_INDEX sign extended
6790 };
6791
6792 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6793 // less than 64K, dynamic symbol index is less than 32K, ABI is N64, and we can
6794 // use only 32-bit instructions.
6795 template<int size, bool big_endian>
6796 const uint32_t
6797 Mips_output_data_mips_stubs<size, big_endian>::
6798 lazy_stub_micromips32_normal_1_n64[] =
6799 {
6800   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6801   0x581f, 0x7950,     // daddu t7,ra,zero
6802   0x03f9, 0x0f3c,     // jalr ra,t9
6803   0x5f00, 0x0000      // daddiu t8,zero,DYN_INDEX sign extended
6804 };
6805
6806 // The format of the microMIPS lazy binding stub when dynamic symbol
6807 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6808 // ABI is not N64, and we can use only 32-bit instructions.
6809 template<int size, bool big_endian>
6810 const uint32_t
6811 Mips_output_data_mips_stubs<size, big_endian>::
6812 lazy_stub_micromips32_normal_2[] =
6813 {
6814   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6815   0x001f, 0x7950,     // addu t7,ra,zero
6816   0x03f9, 0x0f3c,     // jalr ra,t9
6817   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6818 };
6819
6820 // The format of the microMIPS lazy binding stub when dynamic symbol
6821 // count is less than 64K, dynamic symbol index is between 32K and 64K,
6822 // ABI is N64, and we can use only 32-bit instructions.
6823 template<int size, bool big_endian>
6824 const uint32_t
6825 Mips_output_data_mips_stubs<size, big_endian>::
6826 lazy_stub_micromips32_normal_2_n64[] =
6827 {
6828   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6829   0x581f, 0x7950,     // daddu t7,ra,zero
6830   0x03f9, 0x0f3c,     // jalr ra,t9
6831   0x5300, 0x0000      // ori t8,zero,DYN_INDEX unsigned
6832 };
6833
6834 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6835 // greater than 64K, ABI is not N64, and we can use only 32-bit instructions.
6836 template<int size, bool big_endian>
6837 const uint32_t
6838 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big[] =
6839 {
6840   0xff3c, 0x8010,     // lw t9,0x8010(gp)
6841   0x001f, 0x7950,     // addu t7,ra,zero
6842   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6843   0x03f9, 0x0f3c,     // jalr ra,t9
6844   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6845 };
6846
6847 // The format of the microMIPS lazy binding stub when dynamic symbol count is
6848 // greater than 64K, ABI is N64, and we can use only 32-bit instructions.
6849 template<int size, bool big_endian>
6850 const uint32_t
6851 Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big_n64[] =
6852 {
6853   0xdf3c, 0x8010,     // ld t9,0x8010(gp)
6854   0x581f, 0x7950,     // daddu t7,ra,zero
6855   0x41b8, 0x0000,     // lui t8,DYN_INDEX
6856   0x03f9, 0x0f3c,     // jalr ra,t9
6857   0x5318, 0x0000      // ori t8,t8,DYN_INDEX
6858 };
6859
6860 // Create entry for a symbol.
6861
6862 template<int size, bool big_endian>
6863 void
6864 Mips_output_data_mips_stubs<size, big_endian>::make_entry(
6865     Mips_symbol<size>* gsym)
6866 {
6867   if (!gsym->has_lazy_stub() && !gsym->has_plt_offset())
6868     {
6869       this->symbols_.insert(gsym);
6870       gsym->set_has_lazy_stub(true);
6871     }
6872 }
6873
6874 // Remove entry for a symbol.
6875
6876 template<int size, bool big_endian>
6877 void
6878 Mips_output_data_mips_stubs<size, big_endian>::remove_entry(
6879     Mips_symbol<size>* gsym)
6880 {
6881   if (gsym->has_lazy_stub())
6882     {
6883       this->symbols_.erase(gsym);
6884       gsym->set_has_lazy_stub(false);
6885     }
6886 }
6887
6888 // Set stub offsets for symbols.  This method expects that the number of
6889 // entries in dynamic symbol table is set.
6890
6891 template<int size, bool big_endian>
6892 void
6893 Mips_output_data_mips_stubs<size, big_endian>::set_lazy_stub_offsets()
6894 {
6895   gold_assert(this->dynsym_count_ != -1U);
6896
6897   if (this->stub_offsets_are_set_)
6898     return;
6899
6900   unsigned int stub_size = this->stub_size();
6901   unsigned int offset = 0;
6902   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6903        p = this->symbols_.begin();
6904        p != this->symbols_.end();
6905        ++p, offset += stub_size)
6906     {
6907       Mips_symbol<size>* mips_sym = *p;
6908       mips_sym->set_lazy_stub_offset(offset);
6909     }
6910   this->stub_offsets_are_set_ = true;
6911 }
6912
6913 template<int size, bool big_endian>
6914 void
6915 Mips_output_data_mips_stubs<size, big_endian>::set_needs_dynsym_value()
6916 {
6917   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6918        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6919     {
6920       Mips_symbol<size>* sym = *p;
6921       if (sym->is_from_dynobj())
6922         sym->set_needs_dynsym_value();
6923     }
6924 }
6925
6926 // Write out the .MIPS.stubs.  This uses the hand-coded instructions and
6927 // adjusts them as needed.
6928
6929 template<int size, bool big_endian>
6930 void
6931 Mips_output_data_mips_stubs<size, big_endian>::do_write(Output_file* of)
6932 {
6933   const off_t offset = this->offset();
6934   const section_size_type oview_size =
6935     convert_to_section_size_type(this->data_size());
6936   unsigned char* const oview = of->get_output_view(offset, oview_size);
6937
6938   bool big_stub = this->dynsym_count_ > 0x10000;
6939
6940   unsigned char* pov = oview;
6941   for (typename Unordered_set<Mips_symbol<size>*>::const_iterator
6942        p = this->symbols_.begin(); p != this->symbols_.end(); ++p)
6943     {
6944       Mips_symbol<size>* sym = *p;
6945       const uint32_t* lazy_stub;
6946       bool n64 = this->target_->is_output_n64();
6947
6948       if (!this->target_->is_output_micromips())
6949         {
6950           // Write standard (non-microMIPS) stub.
6951           if (!big_stub)
6952             {
6953               if (sym->dynsym_index() & ~0x7fff)
6954                 // Dynsym index is between 32K and 64K.
6955                 lazy_stub = n64 ? lazy_stub_normal_2_n64 : lazy_stub_normal_2;
6956               else
6957                 // Dynsym index is less than 32K.
6958                 lazy_stub = n64 ? lazy_stub_normal_1_n64 : lazy_stub_normal_1;
6959             }
6960           else
6961             lazy_stub = n64 ? lazy_stub_big_n64 : lazy_stub_big;
6962
6963           unsigned int i = 0;
6964           elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]);
6965           elfcpp::Swap<32, big_endian>::writeval(pov + 4, lazy_stub[i + 1]);
6966           pov += 8;
6967
6968           i += 2;
6969           if (big_stub)
6970             {
6971               // LUI instruction of the big stub.  Paste high 16 bits of the
6972               // dynsym index.
6973               elfcpp::Swap<32, big_endian>::writeval(pov,
6974                   lazy_stub[i] | ((sym->dynsym_index() >> 16) & 0x7fff));
6975               pov += 4;
6976               i += 1;
6977             }
6978           elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]);
6979           // Last stub instruction.  Paste low 16 bits of the dynsym index.
6980           elfcpp::Swap<32, big_endian>::writeval(pov + 4,
6981               lazy_stub[i + 1] | (sym->dynsym_index() & 0xffff));
6982           pov += 8;
6983         }
6984       else if (this->target_->use_32bit_micromips_instructions())
6985         {
6986           // Write microMIPS stub in insn32 mode.
6987           if (!big_stub)
6988             {
6989               if (sym->dynsym_index() & ~0x7fff)
6990                 // Dynsym index is between 32K and 64K.
6991                 lazy_stub = n64 ? lazy_stub_micromips32_normal_2_n64
6992                                 : lazy_stub_micromips32_normal_2;
6993               else
6994                 // Dynsym index is less than 32K.
6995                 lazy_stub = n64 ? lazy_stub_micromips32_normal_1_n64
6996                                 : lazy_stub_micromips32_normal_1;
6997             }
6998           else
6999             lazy_stub = n64 ? lazy_stub_micromips32_big_n64
7000                             : lazy_stub_micromips32_big;
7001
7002           unsigned int i = 0;
7003           // First stub instruction.  We emit 32-bit microMIPS instructions by
7004           // emitting two 16-bit parts because on microMIPS the 16-bit part of
7005           // the instruction where the opcode is must always come first, for
7006           // both little and big endian.
7007           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7008           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7009           // Second stub instruction.
7010           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7011           elfcpp::Swap<16, big_endian>::writeval(pov + 6, lazy_stub[i + 3]);
7012           pov += 8;
7013           i += 4;
7014           if (big_stub)
7015             {
7016               // LUI instruction of the big stub.  Paste high 16 bits of the
7017               // dynsym index.
7018               elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7019               elfcpp::Swap<16, big_endian>::writeval(pov + 2,
7020                   (sym->dynsym_index() >> 16) & 0x7fff);
7021               pov += 4;
7022               i += 2;
7023             }
7024           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7025           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7026           // Last stub instruction.  Paste low 16 bits of the dynsym index.
7027           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7028           elfcpp::Swap<16, big_endian>::writeval(pov + 6,
7029               sym->dynsym_index() & 0xffff);
7030           pov += 8;
7031         }
7032       else
7033         {
7034           // Write microMIPS stub.
7035           if (!big_stub)
7036             {
7037               if (sym->dynsym_index() & ~0x7fff)
7038                 // Dynsym index is between 32K and 64K.
7039                 lazy_stub = n64 ? lazy_stub_micromips_normal_2_n64
7040                                 : lazy_stub_micromips_normal_2;
7041               else
7042                 // Dynsym index is less than 32K.
7043                 lazy_stub = n64 ? lazy_stub_micromips_normal_1_n64
7044                                 : lazy_stub_micromips_normal_1;
7045             }
7046           else
7047             lazy_stub = n64 ? lazy_stub_micromips_big_n64
7048                             : lazy_stub_micromips_big;
7049
7050           unsigned int i = 0;
7051           // First stub instruction.  We emit 32-bit microMIPS instructions by
7052           // emitting two 16-bit parts because on microMIPS the 16-bit part of
7053           // the instruction where the opcode is must always come first, for
7054           // both little and big endian.
7055           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7056           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7057           // Second stub instruction.
7058           elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]);
7059           pov += 6;
7060           i += 3;
7061           if (big_stub)
7062             {
7063               // LUI instruction of the big stub.  Paste high 16 bits of the
7064               // dynsym index.
7065               elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7066               elfcpp::Swap<16, big_endian>::writeval(pov + 2,
7067                   (sym->dynsym_index() >> 16) & 0x7fff);
7068               pov += 4;
7069               i += 2;
7070             }
7071           elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]);
7072           // Last stub instruction.  Paste low 16 bits of the dynsym index.
7073           elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]);
7074           elfcpp::Swap<16, big_endian>::writeval(pov + 4,
7075               sym->dynsym_index() & 0xffff);
7076           pov += 6;
7077         }
7078     }
7079
7080   // We always allocate 20 bytes for every stub, because final dynsym count is
7081   // not known in method do_finalize_sections.  There are 4 unused bytes per
7082   // stub if final dynsym count is less than 0x10000.
7083   unsigned int used = pov - oview;
7084   unsigned int unused = big_stub ? 0 : this->symbols_.size() * 4;
7085   gold_assert(static_cast<section_size_type>(used + unused) == oview_size);
7086
7087   // Fill the unused space with zeroes.
7088   // TODO(sasa): Can we strip unused bytes during the relaxation?
7089   if (unused > 0)
7090     memset(pov, 0, unused);
7091
7092   of->write_output_view(offset, oview_size, oview);
7093 }
7094
7095 // Mips_output_section_reginfo methods.
7096
7097 template<int size, bool big_endian>
7098 void
7099 Mips_output_section_reginfo<size, big_endian>::do_write(Output_file* of)
7100 {
7101   off_t offset = this->offset();
7102   off_t data_size = this->data_size();
7103
7104   unsigned char* view = of->get_output_view(offset, data_size);
7105   elfcpp::Swap<size, big_endian>::writeval(view, this->gprmask_);
7106   elfcpp::Swap<size, big_endian>::writeval(view + 4, this->cprmask1_);
7107   elfcpp::Swap<size, big_endian>::writeval(view + 8, this->cprmask2_);
7108   elfcpp::Swap<size, big_endian>::writeval(view + 12, this->cprmask3_);
7109   elfcpp::Swap<size, big_endian>::writeval(view + 16, this->cprmask4_);
7110   // Write the gp value.
7111   elfcpp::Swap<size, big_endian>::writeval(view + 20,
7112                                            this->target_->gp_value());
7113
7114   of->write_output_view(offset, data_size, view);
7115 }
7116
7117 // Mips_copy_relocs methods.
7118
7119 // Emit any saved relocs.
7120
7121 template<int sh_type, int size, bool big_endian>
7122 void
7123 Mips_copy_relocs<sh_type, size, big_endian>::emit_mips(
7124     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section,
7125     Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target)
7126 {
7127   for (typename Copy_relocs<sh_type, size, big_endian>::
7128        Copy_reloc_entries::iterator p = this->entries_.begin();
7129        p != this->entries_.end();
7130        ++p)
7131     emit_entry(*p, reloc_section, symtab, layout, target);
7132
7133   // We no longer need the saved information.
7134   this->entries_.clear();
7135 }
7136
7137 // Emit the reloc if appropriate.
7138
7139 template<int sh_type, int size, bool big_endian>
7140 void
7141 Mips_copy_relocs<sh_type, size, big_endian>::emit_entry(
7142     Copy_reloc_entry& entry,
7143     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section,
7144     Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target)
7145 {
7146   // If the symbol is no longer defined in a dynamic object, then we
7147   // emitted a COPY relocation, and we do not want to emit this
7148   // dynamic relocation.
7149   if (!entry.sym_->is_from_dynobj())
7150     return;
7151
7152   bool can_make_dynamic = (entry.reloc_type_ == elfcpp::R_MIPS_32
7153                            || entry.reloc_type_ == elfcpp::R_MIPS_REL32
7154                            || entry.reloc_type_ == elfcpp::R_MIPS_64);
7155
7156   Mips_symbol<size>* sym = Mips_symbol<size>::as_mips_sym(entry.sym_);
7157   if (can_make_dynamic && !sym->has_static_relocs())
7158     {
7159       Mips_relobj<size, big_endian>* object =
7160         Mips_relobj<size, big_endian>::as_mips_relobj(entry.relobj_);
7161       target->got_section(symtab, layout)->record_global_got_symbol(
7162                           sym, object, entry.reloc_type_, true, false);
7163       if (!symbol_references_local(sym, sym->should_add_dynsym_entry(symtab)))
7164         target->rel_dyn_section(layout)->add_global(sym, elfcpp::R_MIPS_REL32,
7165             entry.output_section_, entry.relobj_, entry.shndx_, entry.address_);
7166       else
7167         target->rel_dyn_section(layout)->add_symbolless_global_addend(
7168             sym, elfcpp::R_MIPS_REL32, entry.output_section_, entry.relobj_,
7169             entry.shndx_, entry.address_);
7170     }
7171   else
7172     this->make_copy_reloc(symtab, layout,
7173                           static_cast<Sized_symbol<size>*>(entry.sym_),
7174                           reloc_section);
7175 }
7176
7177 // Target_mips methods.
7178
7179 // Return the value to use for a dynamic symbol which requires special
7180 // treatment.  This is how we support equality comparisons of function
7181 // pointers across shared library boundaries, as described in the
7182 // processor specific ABI supplement.
7183
7184 template<int size, bool big_endian>
7185 uint64_t
7186 Target_mips<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
7187 {
7188   uint64_t value = 0;
7189   const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
7190
7191   if (!mips_sym->has_lazy_stub())
7192     {
7193       if (mips_sym->has_plt_offset())
7194         {
7195           // We distinguish between PLT entries and lazy-binding stubs by
7196           // giving the former an st_other value of STO_MIPS_PLT.  Set the
7197           // value to the stub address if there are any relocations in the
7198           // binary where pointer equality matters.
7199           if (mips_sym->pointer_equality_needed())
7200             {
7201               // Prefer a standard MIPS PLT entry.
7202               if (mips_sym->has_mips_plt_offset())
7203                 value = this->plt_section()->mips_entry_address(mips_sym);
7204               else
7205                 value = this->plt_section()->comp_entry_address(mips_sym) + 1;
7206             }
7207           else
7208             value = 0;
7209         }
7210     }
7211   else
7212     {
7213       // First, set stub offsets for symbols.  This method expects that the
7214       // number of entries in dynamic symbol table is set.
7215       this->mips_stubs_section()->set_lazy_stub_offsets();
7216
7217       // The run-time linker uses the st_value field of the symbol
7218       // to reset the global offset table entry for this external
7219       // to its stub address when unlinking a shared object.
7220       value = this->mips_stubs_section()->stub_address(mips_sym);
7221     }
7222
7223   if (mips_sym->has_mips16_fn_stub())
7224     {
7225       // If we have a MIPS16 function with a stub, the dynamic symbol must
7226       // refer to the stub, since only the stub uses the standard calling
7227       // conventions.
7228       value = mips_sym->template
7229               get_mips16_fn_stub<big_endian>()->output_address();
7230     }
7231
7232   return value;
7233 }
7234
7235 // Get the dynamic reloc section, creating it if necessary.  It's always
7236 // .rel.dyn, even for MIPS64.
7237
7238 template<int size, bool big_endian>
7239 typename Target_mips<size, big_endian>::Reloc_section*
7240 Target_mips<size, big_endian>::rel_dyn_section(Layout* layout)
7241 {
7242   if (this->rel_dyn_ == NULL)
7243     {
7244       gold_assert(layout != NULL);
7245       this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
7246       layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
7247                                       elfcpp::SHF_ALLOC, this->rel_dyn_,
7248                                       ORDER_DYNAMIC_RELOCS, false);
7249
7250       // First entry in .rel.dyn has to be null.
7251       // This is hack - we define dummy output data and set its address to 0,
7252       // and define absolute R_MIPS_NONE relocation with offset 0 against it.
7253       // This ensures that the entry is null.
7254       Output_data* od = new Output_data_zero_fill(0, 0);
7255       od->set_address(0);
7256       this->rel_dyn_->add_absolute(elfcpp::R_MIPS_NONE, od, 0);
7257     }
7258   return this->rel_dyn_;
7259 }
7260
7261 // Get the GOT section, creating it if necessary.
7262
7263 template<int size, bool big_endian>
7264 Mips_output_data_got<size, big_endian>*
7265 Target_mips<size, big_endian>::got_section(Symbol_table* symtab,
7266                                            Layout* layout)
7267 {
7268   if (this->got_ == NULL)
7269     {
7270       gold_assert(symtab != NULL && layout != NULL);
7271
7272       this->got_ = new Mips_output_data_got<size, big_endian>(this, symtab,
7273                                                               layout);
7274       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
7275                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE |
7276                                       elfcpp::SHF_MIPS_GPREL),
7277                                       this->got_, ORDER_DATA, false);
7278
7279       // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
7280       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
7281                                     Symbol_table::PREDEFINED,
7282                                     this->got_,
7283                                     0, 0, elfcpp::STT_OBJECT,
7284                                     elfcpp::STB_GLOBAL,
7285                                     elfcpp::STV_DEFAULT, 0,
7286                                     false, false);
7287     }
7288
7289   return this->got_;
7290 }
7291
7292 // Calculate value of _gp symbol.
7293
7294 template<int size, bool big_endian>
7295 void
7296 Target_mips<size, big_endian>::set_gp(Layout* layout, Symbol_table* symtab)
7297 {
7298   if (this->gp_ != NULL)
7299     return;
7300
7301   Output_data* section = layout->find_output_section(".got");
7302   if (section == NULL)
7303     {
7304       // If there is no .got section, gp should be based on .sdata.
7305       // TODO(sasa): This is probably not needed.  This was needed for older
7306       // MIPS architectures which accessed both GOT and .sdata section using
7307       // gp-relative addressing.  Modern Mips Linux ELF architectures don't
7308       // access .sdata using gp-relative addressing.
7309       for (Layout::Section_list::const_iterator
7310            p = layout->section_list().begin();
7311            p != layout->section_list().end();
7312            ++p)
7313         {
7314           if (strcmp((*p)->name(), ".sdata") == 0)
7315             {
7316               section = *p;
7317               break;
7318             }
7319         }
7320     }
7321
7322   Sized_symbol<size>* gp =
7323     static_cast<Sized_symbol<size>*>(symtab->lookup("_gp"));
7324   if (gp != NULL)
7325     {
7326       if (gp->source() != Symbol::IS_CONSTANT && section != NULL)
7327         gp->init_output_data(gp->name(), NULL, section, MIPS_GP_OFFSET, 0,
7328                              elfcpp::STT_OBJECT,
7329                              elfcpp::STB_GLOBAL,
7330                              elfcpp::STV_DEFAULT, 0,
7331                              false, false);
7332       this->gp_ = gp;
7333     }
7334   else if (section != NULL)
7335     {
7336       gp = static_cast<Sized_symbol<size>*>(symtab->define_in_output_data(
7337                                       "_gp", NULL, Symbol_table::PREDEFINED,
7338                                       section, MIPS_GP_OFFSET, 0,
7339                                       elfcpp::STT_OBJECT,
7340                                       elfcpp::STB_GLOBAL,
7341                                       elfcpp::STV_DEFAULT,
7342                                       0, false, false));
7343       this->gp_ = gp;
7344     }
7345 }
7346
7347 // Set the dynamic symbol indexes.  INDEX is the index of the first
7348 // global dynamic symbol.  Pointers to the symbols are stored into the
7349 // vector SYMS.  The names are added to DYNPOOL.  This returns an
7350 // updated dynamic symbol index.
7351
7352 template<int size, bool big_endian>
7353 unsigned int
7354 Target_mips<size, big_endian>::do_set_dynsym_indexes(
7355     std::vector<Symbol*>* dyn_symbols, unsigned int index,
7356     std::vector<Symbol*>* syms, Stringpool* dynpool,
7357     Versions* versions, Symbol_table* symtab) const
7358 {
7359   std::vector<Symbol*> non_got_symbols;
7360   std::vector<Symbol*> got_symbols;
7361
7362   reorder_dyn_symbols<size, big_endian>(dyn_symbols, &non_got_symbols,
7363                                         &got_symbols);
7364
7365   for (std::vector<Symbol*>::iterator p = non_got_symbols.begin();
7366        p != non_got_symbols.end();
7367        ++p)
7368     {
7369       Symbol* sym = *p;
7370
7371       // Note that SYM may already have a dynamic symbol index, since
7372       // some symbols appear more than once in the symbol table, with
7373       // and without a version.
7374
7375       if (!sym->has_dynsym_index())
7376         {
7377           sym->set_dynsym_index(index);
7378           ++index;
7379           syms->push_back(sym);
7380           dynpool->add(sym->name(), false, NULL);
7381
7382           // Record any version information.
7383           if (sym->version() != NULL)
7384             versions->record_version(symtab, dynpool, sym);
7385
7386           // If the symbol is defined in a dynamic object and is
7387           // referenced in a regular object, then mark the dynamic
7388           // object as needed.  This is used to implement --as-needed.
7389           if (sym->is_from_dynobj() && sym->in_reg())
7390             sym->object()->set_is_needed();
7391         }
7392     }
7393
7394   for (std::vector<Symbol*>::iterator p = got_symbols.begin();
7395        p != got_symbols.end();
7396        ++p)
7397     {
7398       Symbol* sym = *p;
7399       if (!sym->has_dynsym_index())
7400         {
7401           // Record any version information.
7402           if (sym->version() != NULL)
7403             versions->record_version(symtab, dynpool, sym);
7404         }
7405     }
7406
7407   index = versions->finalize(symtab, index, syms);
7408
7409   int got_sym_count = 0;
7410   for (std::vector<Symbol*>::iterator p = got_symbols.begin();
7411        p != got_symbols.end();
7412        ++p)
7413     {
7414       Symbol* sym = *p;
7415
7416       if (!sym->has_dynsym_index())
7417         {
7418           ++got_sym_count;
7419           sym->set_dynsym_index(index);
7420           ++index;
7421           syms->push_back(sym);
7422           dynpool->add(sym->name(), false, NULL);
7423
7424           // If the symbol is defined in a dynamic object and is
7425           // referenced in a regular object, then mark the dynamic
7426           // object as needed.  This is used to implement --as-needed.
7427           if (sym->is_from_dynobj() && sym->in_reg())
7428             sym->object()->set_is_needed();
7429         }
7430     }
7431
7432   // Set index of the first symbol that has .got entry.
7433   this->got_->set_first_global_got_dynsym_index(
7434     got_sym_count > 0 ? index - got_sym_count : -1U);
7435
7436   if (this->mips_stubs_ != NULL)
7437     this->mips_stubs_->set_dynsym_count(index);
7438
7439   return index;
7440 }
7441
7442 // Create a PLT entry for a global symbol referenced by r_type relocation.
7443
7444 template<int size, bool big_endian>
7445 void
7446 Target_mips<size, big_endian>::make_plt_entry(Symbol_table* symtab,
7447                                               Layout* layout,
7448                                               Mips_symbol<size>* gsym,
7449                                               unsigned int r_type)
7450 {
7451   if (gsym->has_lazy_stub() || gsym->has_plt_offset())
7452     return;
7453
7454   if (this->plt_ == NULL)
7455     {
7456       // Create the GOT section first.
7457       this->got_section(symtab, layout);
7458
7459       this->got_plt_ = new Output_data_space(4, "** GOT PLT");
7460       layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
7461                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE),
7462                                       this->got_plt_, ORDER_DATA, false);
7463
7464       // The first two entries are reserved.
7465       this->got_plt_->set_current_data_size(2 * size/8);
7466
7467       this->plt_ = new Mips_output_data_plt<size, big_endian>(layout,
7468                                                               this->got_plt_,
7469                                                               this);
7470       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
7471                                       (elfcpp::SHF_ALLOC
7472                                        | elfcpp::SHF_EXECINSTR),
7473                                       this->plt_, ORDER_PLT, false);
7474     }
7475
7476   this->plt_->add_entry(gsym, r_type);
7477 }
7478
7479
7480 // Get the .MIPS.stubs section, creating it if necessary.
7481
7482 template<int size, bool big_endian>
7483 Mips_output_data_mips_stubs<size, big_endian>*
7484 Target_mips<size, big_endian>::mips_stubs_section(Layout* layout)
7485 {
7486   if (this->mips_stubs_ == NULL)
7487     {
7488       this->mips_stubs_ =
7489         new Mips_output_data_mips_stubs<size, big_endian>(this);
7490       layout->add_output_section_data(".MIPS.stubs", elfcpp::SHT_PROGBITS,
7491                                       (elfcpp::SHF_ALLOC
7492                                        | elfcpp::SHF_EXECINSTR),
7493                                       this->mips_stubs_, ORDER_PLT, false);
7494     }
7495   return this->mips_stubs_;
7496 }
7497
7498 // Get the LA25 stub section, creating it if necessary.
7499
7500 template<int size, bool big_endian>
7501 Mips_output_data_la25_stub<size, big_endian>*
7502 Target_mips<size, big_endian>::la25_stub_section(Layout* layout)
7503 {
7504   if (this->la25_stub_ == NULL)
7505     {
7506       this->la25_stub_ = new Mips_output_data_la25_stub<size, big_endian>();
7507       layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS,
7508                                       (elfcpp::SHF_ALLOC
7509                                        | elfcpp::SHF_EXECINSTR),
7510                                       this->la25_stub_, ORDER_TEXT, false);
7511     }
7512   return this->la25_stub_;
7513 }
7514
7515 // Process the relocations to determine unreferenced sections for
7516 // garbage collection.
7517
7518 template<int size, bool big_endian>
7519 void
7520 Target_mips<size, big_endian>::gc_process_relocs(
7521                         Symbol_table* symtab,
7522                         Layout* layout,
7523                         Sized_relobj_file<size, big_endian>* object,
7524                         unsigned int data_shndx,
7525                         unsigned int,
7526                         const unsigned char* prelocs,
7527                         size_t reloc_count,
7528                         Output_section* output_section,
7529                         bool needs_special_offset_handling,
7530                         size_t local_symbol_count,
7531                         const unsigned char* plocal_symbols)
7532 {
7533   typedef Target_mips<size, big_endian> Mips;
7534   typedef typename Target_mips<size, big_endian>::Scan Scan;
7535
7536   gold::gc_process_relocs<size, big_endian, Mips, elfcpp::SHT_REL, Scan,
7537                           typename Target_mips::Relocatable_size_for_reloc>(
7538     symtab,
7539     layout,
7540     this,
7541     object,
7542     data_shndx,
7543     prelocs,
7544     reloc_count,
7545     output_section,
7546     needs_special_offset_handling,
7547     local_symbol_count,
7548     plocal_symbols);
7549 }
7550
7551 // Scan relocations for a section.
7552
7553 template<int size, bool big_endian>
7554 void
7555 Target_mips<size, big_endian>::scan_relocs(
7556                         Symbol_table* symtab,
7557                         Layout* layout,
7558                         Sized_relobj_file<size, big_endian>* object,
7559                         unsigned int data_shndx,
7560                         unsigned int sh_type,
7561                         const unsigned char* prelocs,
7562                         size_t reloc_count,
7563                         Output_section* output_section,
7564                         bool needs_special_offset_handling,
7565                         size_t local_symbol_count,
7566                         const unsigned char* plocal_symbols)
7567 {
7568   typedef Target_mips<size, big_endian> Mips;
7569   typedef typename Target_mips<size, big_endian>::Scan Scan;
7570
7571   if (sh_type == elfcpp::SHT_REL)
7572     gold::scan_relocs<size, big_endian, Mips, elfcpp::SHT_REL, Scan>(
7573       symtab,
7574       layout,
7575       this,
7576       object,
7577       data_shndx,
7578       prelocs,
7579       reloc_count,
7580       output_section,
7581       needs_special_offset_handling,
7582       local_symbol_count,
7583       plocal_symbols);
7584   else if (sh_type == elfcpp::SHT_RELA)
7585     gold::scan_relocs<size, big_endian, Mips, elfcpp::SHT_RELA, Scan>(
7586       symtab,
7587       layout,
7588       this,
7589       object,
7590       data_shndx,
7591       prelocs,
7592       reloc_count,
7593       output_section,
7594       needs_special_offset_handling,
7595       local_symbol_count,
7596       plocal_symbols);
7597 }
7598
7599 template<int size, bool big_endian>
7600 bool
7601 Target_mips<size, big_endian>::mips_32bit_flags(elfcpp::Elf_Word flags)
7602 {
7603   return ((flags & elfcpp::EF_MIPS_32BITMODE) != 0
7604           || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_O32
7605           || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_EABI32
7606           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_1
7607           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_2
7608           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32
7609           || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32R2);
7610 }
7611
7612 // Return the MACH for a MIPS e_flags value.
7613 template<int size, bool big_endian>
7614 unsigned int
7615 Target_mips<size, big_endian>::elf_mips_mach(elfcpp::Elf_Word flags)
7616 {
7617   switch (flags & elfcpp::EF_MIPS_MACH)
7618     {
7619     case elfcpp::E_MIPS_MACH_3900:
7620       return mach_mips3900;
7621
7622     case elfcpp::E_MIPS_MACH_4010:
7623       return mach_mips4010;
7624
7625     case elfcpp::E_MIPS_MACH_4100:
7626       return mach_mips4100;
7627
7628     case elfcpp::E_MIPS_MACH_4111:
7629       return mach_mips4111;
7630
7631     case elfcpp::E_MIPS_MACH_4120:
7632       return mach_mips4120;
7633
7634     case elfcpp::E_MIPS_MACH_4650:
7635       return mach_mips4650;
7636
7637     case elfcpp::E_MIPS_MACH_5400:
7638       return mach_mips5400;
7639
7640     case elfcpp::E_MIPS_MACH_5500:
7641       return mach_mips5500;
7642
7643     case elfcpp::E_MIPS_MACH_9000:
7644       return mach_mips9000;
7645
7646     case elfcpp::E_MIPS_MACH_SB1:
7647       return mach_mips_sb1;
7648
7649     case elfcpp::E_MIPS_MACH_LS2E:
7650       return mach_mips_loongson_2e;
7651
7652     case elfcpp::E_MIPS_MACH_LS2F:
7653       return mach_mips_loongson_2f;
7654
7655     case elfcpp::E_MIPS_MACH_LS3A:
7656       return mach_mips_loongson_3a;
7657
7658     case elfcpp::E_MIPS_MACH_OCTEON2:
7659       return mach_mips_octeon2;
7660
7661     case elfcpp::E_MIPS_MACH_OCTEON:
7662       return mach_mips_octeon;
7663
7664     case elfcpp::E_MIPS_MACH_XLR:
7665       return mach_mips_xlr;
7666
7667     default:
7668       switch (flags & elfcpp::EF_MIPS_ARCH)
7669         {
7670         default:
7671         case elfcpp::E_MIPS_ARCH_1:
7672           return mach_mips3000;
7673
7674         case elfcpp::E_MIPS_ARCH_2:
7675           return mach_mips6000;
7676
7677         case elfcpp::E_MIPS_ARCH_3:
7678           return mach_mips4000;
7679
7680         case elfcpp::E_MIPS_ARCH_4:
7681           return mach_mips8000;
7682
7683         case elfcpp::E_MIPS_ARCH_5:
7684           return mach_mips5;
7685
7686         case elfcpp::E_MIPS_ARCH_32:
7687           return mach_mipsisa32;
7688
7689         case elfcpp::E_MIPS_ARCH_64:
7690           return mach_mipsisa64;
7691
7692         case elfcpp::E_MIPS_ARCH_32R2:
7693           return mach_mipsisa32r2;
7694
7695         case elfcpp::E_MIPS_ARCH_64R2:
7696           return mach_mipsisa64r2;
7697         }
7698     }
7699
7700   return 0;
7701 }
7702
7703 // Check whether machine EXTENSION is an extension of machine BASE.
7704 template<int size, bool big_endian>
7705 bool
7706 Target_mips<size, big_endian>::mips_mach_extends(unsigned int base,
7707                                                  unsigned int extension)
7708 {
7709   if (extension == base)
7710     return true;
7711
7712   if ((base == mach_mipsisa32)
7713       && this->mips_mach_extends(mach_mipsisa64, extension))
7714     return true;
7715
7716   if ((base == mach_mipsisa32r2)
7717       && this->mips_mach_extends(mach_mipsisa64r2, extension))
7718     return true;
7719
7720   for (unsigned int i = 0; i < this->mips_mach_extensions_.size(); ++i)
7721     if (extension == this->mips_mach_extensions_[i].first)
7722       {
7723         extension = this->mips_mach_extensions_[i].second;
7724         if (extension == base)
7725           return true;
7726       }
7727
7728   return false;
7729 }
7730
7731 template<int size, bool big_endian>
7732 void
7733 Target_mips<size, big_endian>::merge_processor_specific_flags(
7734     const std::string& name, elfcpp::Elf_Word in_flags,
7735     unsigned char in_ei_class, bool dyn_obj)
7736 {
7737   // If flags are not set yet, just copy them.
7738   if (!this->are_processor_specific_flags_set())
7739     {
7740       this->set_processor_specific_flags(in_flags);
7741       this->ei_class_ = in_ei_class;
7742       this->mach_ = this->elf_mips_mach(in_flags);
7743       return;
7744     }
7745
7746   elfcpp::Elf_Word new_flags = in_flags;
7747   elfcpp::Elf_Word old_flags = this->processor_specific_flags();
7748   elfcpp::Elf_Word merged_flags = this->processor_specific_flags();
7749   merged_flags |= new_flags & elfcpp::EF_MIPS_NOREORDER;
7750
7751   // Check flag compatibility.
7752   new_flags &= ~elfcpp::EF_MIPS_NOREORDER;
7753   old_flags &= ~elfcpp::EF_MIPS_NOREORDER;
7754
7755   // Some IRIX 6 BSD-compatibility objects have this bit set.  It
7756   // doesn't seem to matter.
7757   new_flags &= ~elfcpp::EF_MIPS_XGOT;
7758   old_flags &= ~elfcpp::EF_MIPS_XGOT;
7759
7760   // MIPSpro generates ucode info in n64 objects.  Again, we should
7761   // just be able to ignore this.
7762   new_flags &= ~elfcpp::EF_MIPS_UCODE;
7763   old_flags &= ~elfcpp::EF_MIPS_UCODE;
7764
7765   // DSOs should only be linked with CPIC code.
7766   if (dyn_obj)
7767     new_flags |= elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC;
7768
7769   if (new_flags == old_flags)
7770     {
7771       this->set_processor_specific_flags(merged_flags);
7772       return;
7773     }
7774
7775   if (((new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0)
7776       != ((old_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0))
7777     gold_warning(_("%s: linking abicalls files with non-abicalls files"),
7778                  name.c_str());
7779
7780   if (new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC))
7781     merged_flags |= elfcpp::EF_MIPS_CPIC;
7782   if (!(new_flags & elfcpp::EF_MIPS_PIC))
7783     merged_flags &= ~elfcpp::EF_MIPS_PIC;
7784
7785   new_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC);
7786   old_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC);
7787
7788   // Compare the ISAs.
7789   if (mips_32bit_flags(old_flags) != mips_32bit_flags(new_flags))
7790     gold_error(_("%s: linking 32-bit code with 64-bit code"), name.c_str());
7791   else if (!this->mips_mach_extends(this->elf_mips_mach(in_flags), this->mach_))
7792     {
7793       // Output ISA isn't the same as, or an extension of, input ISA.
7794       if (this->mips_mach_extends(this->mach_, this->elf_mips_mach(in_flags)))
7795         {
7796           // Copy the architecture info from input object to output.  Also copy
7797           // the 32-bit flag (if set) so that we continue to recognise
7798           // output as a 32-bit binary.
7799           this->mach_ = this->elf_mips_mach(in_flags);
7800           merged_flags &= ~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH);
7801           merged_flags |= (new_flags & (elfcpp::EF_MIPS_ARCH
7802                            | elfcpp::EF_MIPS_MACH | elfcpp::EF_MIPS_32BITMODE));
7803
7804           // Copy across the ABI flags if output doesn't use them
7805           // and if that was what caused us to treat input object as 32-bit.
7806           if ((old_flags & elfcpp::EF_MIPS_ABI) == 0
7807               && this->mips_32bit_flags(new_flags)
7808               && !this->mips_32bit_flags(new_flags & ~elfcpp::EF_MIPS_ABI))
7809             merged_flags |= new_flags & elfcpp::EF_MIPS_ABI;
7810         }
7811       else
7812         // The ISAs aren't compatible.
7813         gold_error(_("%s: linking %s module with previous %s modules"),
7814                    name.c_str(), this->elf_mips_mach_name(in_flags),
7815                    this->elf_mips_mach_name(merged_flags));
7816     }
7817
7818   new_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH
7819                 | elfcpp::EF_MIPS_32BITMODE));
7820   old_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH
7821                 | elfcpp::EF_MIPS_32BITMODE));
7822
7823   // Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI. But, it does set
7824   // EI_CLASS differently from any 32-bit ABI.
7825   if ((new_flags & elfcpp::EF_MIPS_ABI) != (old_flags & elfcpp::EF_MIPS_ABI)
7826       || (in_ei_class != this->ei_class_))
7827     {
7828       // Only error if both are set (to different values).
7829       if (((new_flags & elfcpp::EF_MIPS_ABI)
7830            && (old_flags & elfcpp::EF_MIPS_ABI))
7831           || (in_ei_class != this->ei_class_))
7832         gold_error(_("%s: ABI mismatch: linking %s module with "
7833                      "previous %s modules"), name.c_str(),
7834                    this->elf_mips_abi_name(in_flags, in_ei_class),
7835                    this->elf_mips_abi_name(merged_flags, this->ei_class_));
7836
7837       new_flags &= ~elfcpp::EF_MIPS_ABI;
7838       old_flags &= ~elfcpp::EF_MIPS_ABI;
7839     }
7840
7841   // Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
7842   // and allow arbitrary mixing of the remaining ASEs (retain the union).
7843   if ((new_flags & elfcpp::EF_MIPS_ARCH_ASE)
7844       != (old_flags & elfcpp::EF_MIPS_ARCH_ASE))
7845     {
7846       int old_micro = old_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS;
7847       int new_micro = new_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS;
7848       int old_m16 = old_flags & elfcpp::EF_MIPS_ARCH_ASE_M16;
7849       int new_m16 = new_flags & elfcpp::EF_MIPS_ARCH_ASE_M16;
7850       int micro_mis = old_m16 && new_micro;
7851       int m16_mis = old_micro && new_m16;
7852
7853       if (m16_mis || micro_mis)
7854         gold_error(_("%s: ASE mismatch: linking %s module with "
7855                      "previous %s modules"), name.c_str(),
7856                    m16_mis ? "MIPS16" : "microMIPS",
7857                    m16_mis ? "microMIPS" : "MIPS16");
7858
7859       merged_flags |= new_flags & elfcpp::EF_MIPS_ARCH_ASE;
7860
7861       new_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE;
7862       old_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE;
7863     }
7864
7865   // Warn about any other mismatches.
7866   if (new_flags != old_flags)
7867     gold_error(_("%s: uses different e_flags (0x%x) fields than previous "
7868                  "modules (0x%x)"), name.c_str(), new_flags, old_flags);
7869
7870   this->set_processor_specific_flags(merged_flags);
7871 }
7872
7873 // Adjust ELF file header.
7874
7875 template<int size, bool big_endian>
7876 void
7877 Target_mips<size, big_endian>::do_adjust_elf_header(
7878     unsigned char* view,
7879     int len)
7880 {
7881   gold_assert(len == elfcpp::Elf_sizes<size>::ehdr_size);
7882
7883   elfcpp::Ehdr<size, big_endian> ehdr(view);
7884   unsigned char e_ident[elfcpp::EI_NIDENT];
7885   memcpy(e_ident, ehdr.get_e_ident(), elfcpp::EI_NIDENT);
7886
7887   e_ident[elfcpp::EI_CLASS] = this->ei_class_;
7888
7889   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
7890   oehdr.put_e_ident(e_ident);
7891   if (this->entry_symbol_is_compressed_)
7892     oehdr.put_e_entry(ehdr.get_e_entry() + 1);
7893 }
7894
7895 // do_make_elf_object to override the same function in the base class.
7896 // We need to use a target-specific sub-class of
7897 // Sized_relobj_file<size, big_endian> to store Mips specific information.
7898 // Hence we need to have our own ELF object creation.
7899
7900 template<int size, bool big_endian>
7901 Object*
7902 Target_mips<size, big_endian>::do_make_elf_object(
7903     const std::string& name,
7904     Input_file* input_file,
7905     off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
7906 {
7907   int et = ehdr.get_e_type();
7908   // ET_EXEC files are valid input for --just-symbols/-R,
7909   // and we treat them as relocatable objects.
7910   if (et == elfcpp::ET_REL
7911       || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
7912     {
7913       Mips_relobj<size, big_endian>* obj =
7914         new Mips_relobj<size, big_endian>(name, input_file, offset, ehdr);
7915       obj->setup();
7916       return obj;
7917     }
7918   else if (et == elfcpp::ET_DYN)
7919     {
7920       // TODO(sasa): Should we create Mips_dynobj?
7921       return Target::do_make_elf_object(name, input_file, offset, ehdr);
7922     }
7923   else
7924     {
7925       gold_error(_("%s: unsupported ELF file type %d"),
7926                  name.c_str(), et);
7927       return NULL;
7928     }
7929 }
7930
7931 // Finalize the sections.
7932
7933 template <int size, bool big_endian>
7934 void
7935 Target_mips<size, big_endian>::do_finalize_sections(Layout* layout,
7936                                         const Input_objects* input_objects,
7937                                         Symbol_table* symtab)
7938 {
7939   // Add +1 to MIPS16 and microMIPS init_ and _fini symbols so that DT_INIT and
7940   // DT_FINI have correct values.
7941   Mips_symbol<size>* init = static_cast<Mips_symbol<size>*>(
7942       symtab->lookup(parameters->options().init()));
7943   if (init != NULL && (init->is_mips16() || init->is_micromips()))
7944     init->set_value(init->value() | 1);
7945   Mips_symbol<size>* fini = static_cast<Mips_symbol<size>*>(
7946       symtab->lookup(parameters->options().fini()));
7947   if (fini != NULL && (fini->is_mips16() || fini->is_micromips()))
7948     fini->set_value(fini->value() | 1);
7949
7950   // Check whether the entry symbol is mips16 or micromips.  This is needed to
7951   // adjust entry address in ELF header.
7952   Mips_symbol<size>* entry =
7953     static_cast<Mips_symbol<size>*>(symtab->lookup(this->entry_symbol_name()));
7954   this->entry_symbol_is_compressed_ = (entry != NULL && (entry->is_mips16()
7955                                        || entry->is_micromips()));
7956
7957   if (!parameters->doing_static_link()
7958       && (strcmp(parameters->options().hash_style(), "gnu") == 0
7959           || strcmp(parameters->options().hash_style(), "both") == 0))
7960     {
7961       // .gnu.hash and the MIPS ABI require .dynsym to be sorted in different
7962       // ways.  .gnu.hash needs symbols to be grouped by hash code whereas the
7963       // MIPS ABI requires a mapping between the GOT and the symbol table.
7964       gold_error(".gnu.hash is incompatible with the MIPS ABI");
7965     }
7966
7967   // Check whether the final section that was scanned has HI16 or GOT16
7968   // relocations without the corresponding LO16 part.
7969   if (this->got16_addends_.size() > 0)
7970       gold_error("Can't find matching LO16 reloc");
7971
7972   // Set _gp value.
7973   this->set_gp(layout, symtab);
7974
7975   // Check for any mips16 stub sections that we can discard.
7976   if (!parameters->options().relocatable())
7977     {
7978       for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
7979           p != input_objects->relobj_end();
7980           ++p)
7981         {
7982           Mips_relobj<size, big_endian>* object =
7983             Mips_relobj<size, big_endian>::as_mips_relobj(*p);
7984           object->discard_mips16_stub_sections(symtab);
7985         }
7986     }
7987
7988   // Merge processor-specific flags.
7989   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
7990        p != input_objects->relobj_end();
7991        ++p)
7992     {
7993       Mips_relobj<size, big_endian>* relobj =
7994         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
7995
7996       Input_file::Format format = relobj->input_file()->format();
7997       if (format == Input_file::FORMAT_ELF)
7998         {
7999           // Read processor-specific flags in ELF file header.
8000           const unsigned char* pehdr = relobj->get_view(
8001                                             elfcpp::file_header_offset,
8002                                             elfcpp::Elf_sizes<size>::ehdr_size,
8003                                             true, false);
8004
8005           elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
8006           elfcpp::Elf_Word in_flags = ehdr.get_e_flags();
8007           unsigned char ei_class = ehdr.get_e_ident()[elfcpp::EI_CLASS];
8008
8009           this->merge_processor_specific_flags(relobj->name(), in_flags,
8010                                                ei_class, false);
8011         }
8012     }
8013
8014   for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
8015        p != input_objects->dynobj_end();
8016        ++p)
8017     {
8018       Sized_dynobj<size, big_endian>* dynobj =
8019         static_cast<Sized_dynobj<size, big_endian>*>(*p);
8020
8021       // Read processor-specific flags.
8022       const unsigned char* pehdr = dynobj->get_view(elfcpp::file_header_offset,
8023                                            elfcpp::Elf_sizes<size>::ehdr_size,
8024                                            true, false);
8025
8026       elfcpp::Ehdr<size, big_endian> ehdr(pehdr);
8027       elfcpp::Elf_Word in_flags = ehdr.get_e_flags();
8028       unsigned char ei_class = ehdr.get_e_ident()[elfcpp::EI_CLASS];
8029
8030       this->merge_processor_specific_flags(dynobj->name(), in_flags, ei_class,
8031                                            true);
8032     }
8033
8034   // Merge .reginfo contents of input objects.
8035   Valtype gprmask = 0;
8036   Valtype cprmask1 = 0;
8037   Valtype cprmask2 = 0;
8038   Valtype cprmask3 = 0;
8039   Valtype cprmask4 = 0;
8040   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
8041        p != input_objects->relobj_end();
8042        ++p)
8043     {
8044       Mips_relobj<size, big_endian>* relobj =
8045         Mips_relobj<size, big_endian>::as_mips_relobj(*p);
8046
8047       gprmask |= relobj->gprmask();
8048       cprmask1 |= relobj->cprmask1();
8049       cprmask2 |= relobj->cprmask2();
8050       cprmask3 |= relobj->cprmask3();
8051       cprmask4 |= relobj->cprmask4();
8052     }
8053
8054   if (this->plt_ != NULL)
8055     {
8056       // Set final PLT offsets for symbols.
8057       this->plt_section()->set_plt_offsets();
8058
8059       // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
8060       // Set STO_MICROMIPS flag if the output has microMIPS code, but only if
8061       // there are no standard PLT entries present.
8062       unsigned char nonvis = 0;
8063       if (this->is_output_micromips()
8064           && !this->plt_section()->has_standard_entries())
8065         nonvis = elfcpp::STO_MICROMIPS >> 2;
8066       symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
8067                                     Symbol_table::PREDEFINED,
8068                                     this->plt_,
8069                                     0, 0, elfcpp::STT_FUNC,
8070                                     elfcpp::STB_LOCAL,
8071                                     elfcpp::STV_DEFAULT, nonvis,
8072                                     false, false);
8073     }
8074
8075   if (this->mips_stubs_ != NULL)
8076     {
8077       // Define _MIPS_STUBS_ at the start of the .MIPS.stubs section.
8078       unsigned char nonvis = 0;
8079       if (this->is_output_micromips())
8080         nonvis = elfcpp::STO_MICROMIPS >> 2;
8081       symtab->define_in_output_data("_MIPS_STUBS_", NULL,
8082                                     Symbol_table::PREDEFINED,
8083                                     this->mips_stubs_,
8084                                     0, 0, elfcpp::STT_FUNC,
8085                                     elfcpp::STB_LOCAL,
8086                                     elfcpp::STV_DEFAULT, nonvis,
8087                                     false, false);
8088     }
8089
8090   if (!parameters->options().relocatable() && !parameters->doing_static_link())
8091     // In case there is no .got section, create one.
8092     this->got_section(symtab, layout);
8093
8094   // Emit any relocs we saved in an attempt to avoid generating COPY
8095   // relocs.
8096   if (this->copy_relocs_.any_saved_relocs())
8097     this->copy_relocs_.emit_mips(this->rel_dyn_section(layout), symtab, layout,
8098                                  this);
8099
8100   // Emit dynamic relocs.
8101   for (typename std::vector<Dyn_reloc>::iterator p = this->dyn_relocs_.begin();
8102        p != this->dyn_relocs_.end();
8103        ++p)
8104     p->emit(this->rel_dyn_section(layout), this->got_section(), symtab);
8105
8106   if (this->has_got_section())
8107     this->got_section()->lay_out_got(layout, symtab, input_objects);
8108
8109   if (this->mips_stubs_ != NULL)
8110     this->mips_stubs_->set_needs_dynsym_value();
8111
8112   // Check for functions that might need $25 to be valid on entry.
8113   // TODO(sasa): Can we do this without iterating over all symbols?
8114   typedef Symbol_visitor_check_symbols<size, big_endian> Symbol_visitor;
8115   symtab->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(this, layout,
8116                                                                symtab));
8117
8118   // Add NULL segment.
8119   if (!parameters->options().relocatable())
8120     layout->make_output_segment(elfcpp::PT_NULL, 0);
8121
8122   for (Layout::Section_list::const_iterator p = layout->section_list().begin();
8123        p != layout->section_list().end();
8124        ++p)
8125     {
8126       if ((*p)->type() == elfcpp::SHT_MIPS_REGINFO)
8127         {
8128           Mips_output_section_reginfo<size, big_endian>* reginfo =
8129             Mips_output_section_reginfo<size, big_endian>::
8130               as_mips_output_section_reginfo(*p);
8131
8132           reginfo->set_masks(gprmask, cprmask1, cprmask2, cprmask3, cprmask4);
8133
8134           if (!parameters->options().relocatable())
8135             {
8136               Output_segment* reginfo_segment =
8137                 layout->make_output_segment(elfcpp::PT_MIPS_REGINFO,
8138                                             elfcpp::PF_R);
8139               reginfo_segment->add_output_section_to_nonload(reginfo,
8140                                                              elfcpp::PF_R);
8141             }
8142         }
8143     }
8144
8145   // Fill in some more dynamic tags.
8146   // TODO(sasa): Add more dynamic tags.
8147   const Reloc_section* rel_plt = (this->plt_ == NULL
8148                                   ? NULL : this->plt_->rel_plt());
8149   layout->add_target_dynamic_tags(true, this->got_, rel_plt,
8150                                   this->rel_dyn_, true, false);
8151
8152   Output_data_dynamic* const odyn = layout->dynamic_data();
8153   if (odyn != NULL
8154       && !parameters->options().relocatable()
8155       && !parameters->doing_static_link())
8156   {
8157     unsigned int d_val;
8158     // This element holds a 32-bit version id for the Runtime
8159     // Linker Interface.  This will start at integer value 1.
8160     d_val = 0x01;
8161     odyn->add_constant(elfcpp::DT_MIPS_RLD_VERSION, d_val);
8162
8163     // Dynamic flags
8164     d_val = elfcpp::RHF_NOTPOT;
8165     odyn->add_constant(elfcpp::DT_MIPS_FLAGS, d_val);
8166
8167     // Save layout for using when emiting custom dynamic tags.
8168     this->layout_ = layout;
8169
8170     // This member holds the base address of the segment.
8171     odyn->add_custom(elfcpp::DT_MIPS_BASE_ADDRESS);
8172
8173     // This member holds the number of entries in the .dynsym section.
8174     odyn->add_custom(elfcpp::DT_MIPS_SYMTABNO);
8175
8176     // This member holds the index of the first dynamic symbol
8177     // table entry that corresponds to an entry in the global offset table.
8178     odyn->add_custom(elfcpp::DT_MIPS_GOTSYM);
8179
8180     // This member holds the number of local GOT entries.
8181     odyn->add_constant(elfcpp::DT_MIPS_LOCAL_GOTNO,
8182                        this->got_->get_local_gotno());
8183
8184     if (this->plt_ != NULL)
8185       // DT_MIPS_PLTGOT dynamic tag
8186       odyn->add_section_address(elfcpp::DT_MIPS_PLTGOT, this->got_plt_);
8187   }
8188  }
8189
8190 // Get the custom dynamic tag value.
8191 template<int size, bool big_endian>
8192 unsigned int
8193 Target_mips<size, big_endian>::do_dynamic_tag_custom_value(elfcpp::DT tag) const
8194 {
8195   switch (tag)
8196     {
8197     case elfcpp::DT_MIPS_BASE_ADDRESS:
8198       {
8199         // The base address of the segment.
8200         // At this point, the segment list has been sorted into final order,
8201         // so just return vaddr of the first readable PT_LOAD segment.
8202         Output_segment* seg =
8203           this->layout_->find_output_segment(elfcpp::PT_LOAD, elfcpp::PF_R, 0);
8204         gold_assert(seg != NULL);
8205         return seg->vaddr();
8206       }
8207
8208     case elfcpp::DT_MIPS_SYMTABNO:
8209       // The number of entries in the .dynsym section.
8210       return this->get_dt_mips_symtabno();
8211
8212     case elfcpp::DT_MIPS_GOTSYM:
8213       {
8214         // The index of the first dynamic symbol table entry that corresponds
8215         // to an entry in the GOT.
8216         if (this->got_->first_global_got_dynsym_index() != -1U)
8217           return this->got_->first_global_got_dynsym_index();
8218         else
8219           // In case if we don't have global GOT symbols we default to setting
8220           // DT_MIPS_GOTSYM to the same value as DT_MIPS_SYMTABNO.
8221           return this->get_dt_mips_symtabno();
8222       }
8223
8224     default:
8225       gold_error(_("Unknown dynamic tag 0x%x"), (unsigned int)tag);
8226     }
8227
8228   return (unsigned int)-1;
8229 }
8230
8231 // Relocate section data.
8232
8233 template<int size, bool big_endian>
8234 void
8235 Target_mips<size, big_endian>::relocate_section(
8236                         const Relocate_info<size, big_endian>* relinfo,
8237                         unsigned int sh_type,
8238                         const unsigned char* prelocs,
8239                         size_t reloc_count,
8240                         Output_section* output_section,
8241                         bool needs_special_offset_handling,
8242                         unsigned char* view,
8243                         Mips_address address,
8244                         section_size_type view_size,
8245                         const Reloc_symbol_changes* reloc_symbol_changes)
8246 {
8247   typedef Target_mips<size, big_endian> Mips;
8248   typedef typename Target_mips<size, big_endian>::Relocate Mips_relocate;
8249
8250   if (sh_type == elfcpp::SHT_REL)
8251     gold::relocate_section<size, big_endian, Mips, elfcpp::SHT_REL,
8252       Mips_relocate, gold::Default_comdat_behavior>(
8253       relinfo,
8254       this,
8255       prelocs,
8256       reloc_count,
8257       output_section,
8258       needs_special_offset_handling,
8259       view,
8260       address,
8261       view_size,
8262       reloc_symbol_changes);
8263   else if (sh_type == elfcpp::SHT_RELA)
8264     gold::relocate_section<size, big_endian, Mips, elfcpp::SHT_RELA,
8265       Mips_relocate, gold::Default_comdat_behavior>(
8266       relinfo,
8267       this,
8268       prelocs,
8269       reloc_count,
8270       output_section,
8271       needs_special_offset_handling,
8272       view,
8273       address,
8274       view_size,
8275      reloc_symbol_changes);
8276 }
8277
8278 // Return the size of a relocation while scanning during a relocatable
8279 // link.
8280
8281 template<int size, bool big_endian>
8282 unsigned int
8283 Target_mips<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
8284     unsigned int r_type,
8285     Relobj* object)
8286 {
8287   switch (r_type)
8288     {
8289     case elfcpp::R_MIPS_NONE:
8290     case elfcpp::R_MIPS_TLS_DTPMOD64:
8291     case elfcpp::R_MIPS_TLS_DTPREL64:
8292     case elfcpp::R_MIPS_TLS_TPREL64:
8293       return 0;
8294
8295     case elfcpp::R_MIPS_32:
8296     case elfcpp::R_MIPS_TLS_DTPMOD32:
8297     case elfcpp::R_MIPS_TLS_DTPREL32:
8298     case elfcpp::R_MIPS_TLS_TPREL32:
8299     case elfcpp::R_MIPS_REL32:
8300     case elfcpp::R_MIPS_PC32:
8301     case elfcpp::R_MIPS_GPREL32:
8302     case elfcpp::R_MIPS_JALR:
8303       return 4;
8304
8305     case elfcpp::R_MIPS_16:
8306     case elfcpp::R_MIPS_HI16:
8307     case elfcpp::R_MIPS_LO16:
8308     case elfcpp::R_MIPS_GPREL16:
8309     case elfcpp::R_MIPS16_HI16:
8310     case elfcpp::R_MIPS16_LO16:
8311     case elfcpp::R_MIPS_PC16:
8312     case elfcpp::R_MIPS_GOT16:
8313     case elfcpp::R_MIPS16_GOT16:
8314     case elfcpp::R_MIPS_CALL16:
8315     case elfcpp::R_MIPS16_CALL16:
8316     case elfcpp::R_MIPS_GOT_HI16:
8317     case elfcpp::R_MIPS_CALL_HI16:
8318     case elfcpp::R_MIPS_GOT_LO16:
8319     case elfcpp::R_MIPS_CALL_LO16:
8320     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
8321     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
8322     case elfcpp::R_MIPS_TLS_TPREL_HI16:
8323     case elfcpp::R_MIPS_TLS_TPREL_LO16:
8324     case elfcpp::R_MIPS16_GPREL:
8325     case elfcpp::R_MIPS_GOT_DISP:
8326     case elfcpp::R_MIPS_LITERAL:
8327     case elfcpp::R_MIPS_GOT_PAGE:
8328     case elfcpp::R_MIPS_GOT_OFST:
8329     case elfcpp::R_MIPS_TLS_GD:
8330     case elfcpp::R_MIPS_TLS_LDM:
8331     case elfcpp::R_MIPS_TLS_GOTTPREL:
8332       return 2;
8333
8334     // These relocations are not byte sized
8335     case elfcpp::R_MIPS_26:
8336     case elfcpp::R_MIPS16_26:
8337       return 4;
8338
8339     case elfcpp::R_MIPS_COPY:
8340     case elfcpp::R_MIPS_JUMP_SLOT:
8341       object->error(_("unexpected reloc %u in object file"), r_type);
8342       return 0;
8343
8344     default:
8345       object->error(_("unsupported reloc %u in object file"), r_type);
8346       return 0;
8347   }
8348 }
8349
8350 // Scan the relocs during a relocatable link.
8351
8352 template<int size, bool big_endian>
8353 void
8354 Target_mips<size, big_endian>::scan_relocatable_relocs(
8355                         Symbol_table* symtab,
8356                         Layout* layout,
8357                         Sized_relobj_file<size, big_endian>* object,
8358                         unsigned int data_shndx,
8359                         unsigned int sh_type,
8360                         const unsigned char* prelocs,
8361                         size_t reloc_count,
8362                         Output_section* output_section,
8363                         bool needs_special_offset_handling,
8364                         size_t local_symbol_count,
8365                         const unsigned char* plocal_symbols,
8366                         Relocatable_relocs* rr)
8367 {
8368   gold_assert(sh_type == elfcpp::SHT_REL);
8369
8370   typedef Mips_scan_relocatable_relocs<big_endian, elfcpp::SHT_REL,
8371     Relocatable_size_for_reloc> Scan_relocatable_relocs;
8372
8373   gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_REL,
8374     Scan_relocatable_relocs>(
8375     symtab,
8376     layout,
8377     object,
8378     data_shndx,
8379     prelocs,
8380     reloc_count,
8381     output_section,
8382     needs_special_offset_handling,
8383     local_symbol_count,
8384     plocal_symbols,
8385     rr);
8386 }
8387
8388 // Emit relocations for a section.
8389
8390 template<int size, bool big_endian>
8391 void
8392 Target_mips<size, big_endian>::relocate_relocs(
8393                         const Relocate_info<size, big_endian>* relinfo,
8394                         unsigned int sh_type,
8395                         const unsigned char* prelocs,
8396                         size_t reloc_count,
8397                         Output_section* output_section,
8398                         typename elfcpp::Elf_types<size>::Elf_Off
8399                           offset_in_output_section,
8400                         const Relocatable_relocs* rr,
8401                         unsigned char* view,
8402                         Mips_address view_address,
8403                         section_size_type view_size,
8404                         unsigned char* reloc_view,
8405                         section_size_type reloc_view_size)
8406 {
8407   gold_assert(sh_type == elfcpp::SHT_REL);
8408
8409   gold::relocate_relocs<size, big_endian, elfcpp::SHT_REL>(
8410     relinfo,
8411     prelocs,
8412     reloc_count,
8413     output_section,
8414     offset_in_output_section,
8415     rr,
8416     view,
8417     view_address,
8418     view_size,
8419     reloc_view,
8420     reloc_view_size);
8421 }
8422
8423 // Perform target-specific processing in a relocatable link.  This is
8424 // only used if we use the relocation strategy RELOC_SPECIAL.
8425
8426 template<int size, bool big_endian>
8427 void
8428 Target_mips<size, big_endian>::relocate_special_relocatable(
8429     const Relocate_info<size, big_endian>* relinfo,
8430     unsigned int sh_type,
8431     const unsigned char* preloc_in,
8432     size_t relnum,
8433     Output_section* output_section,
8434     typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
8435     unsigned char* view,
8436     Mips_address view_address,
8437     section_size_type,
8438     unsigned char* preloc_out)
8439 {
8440   // We can only handle REL type relocation sections.
8441   gold_assert(sh_type == elfcpp::SHT_REL);
8442
8443   typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc
8444     Reltype;
8445   typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc_write
8446     Reltype_write;
8447
8448   typedef Mips_relocate_functions<size, big_endian> Reloc_funcs;
8449
8450   const Mips_address invalid_address = static_cast<Mips_address>(0) - 1;
8451
8452   Mips_relobj<size, big_endian>* object =
8453     Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object);
8454   const unsigned int local_count = object->local_symbol_count();
8455
8456   Reltype reloc(preloc_in);
8457   Reltype_write reloc_write(preloc_out);
8458
8459   elfcpp::Elf_types<32>::Elf_WXword r_info = reloc.get_r_info();
8460   const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8461   const unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
8462
8463   // Get the new symbol index.
8464   // We only use RELOC_SPECIAL strategy in local relocations.
8465   gold_assert(r_sym < local_count);
8466
8467   // We are adjusting a section symbol.  We need to find
8468   // the symbol table index of the section symbol for
8469   // the output section corresponding to input section
8470   // in which this symbol is defined.
8471   bool is_ordinary;
8472   unsigned int shndx = object->local_symbol_input_shndx(r_sym, &is_ordinary);
8473   gold_assert(is_ordinary);
8474   Output_section* os = object->output_section(shndx);
8475   gold_assert(os != NULL);
8476   gold_assert(os->needs_symtab_index());
8477   unsigned int new_symndx = os->symtab_index();
8478
8479   // Get the new offset--the location in the output section where
8480   // this relocation should be applied.
8481
8482   Mips_address offset = reloc.get_r_offset();
8483   Mips_address new_offset;
8484   if (offset_in_output_section != invalid_address)
8485     new_offset = offset + offset_in_output_section;
8486   else
8487     {
8488       section_offset_type sot_offset =
8489         convert_types<section_offset_type, Mips_address>(offset);
8490       section_offset_type new_sot_offset =
8491         output_section->output_offset(object, relinfo->data_shndx,
8492                                       sot_offset);
8493       gold_assert(new_sot_offset != -1);
8494       new_offset = new_sot_offset;
8495     }
8496
8497   // In an object file, r_offset is an offset within the section.
8498   // In an executable or dynamic object, generated by
8499   // --emit-relocs, r_offset is an absolute address.
8500   if (!parameters->options().relocatable())
8501     {
8502       new_offset += view_address;
8503       if (offset_in_output_section != invalid_address)
8504         new_offset -= offset_in_output_section;
8505     }
8506
8507   reloc_write.put_r_offset(new_offset);
8508   reloc_write.put_r_info(elfcpp::elf_r_info<32>(new_symndx, r_type));
8509
8510   // Handle the reloc addend.
8511   // The relocation uses a section symbol in the input file.
8512   // We are adjusting it to use a section symbol in the output
8513   // file.  The input section symbol refers to some address in
8514   // the input section.  We need the relocation in the output
8515   // file to refer to that same address.  This adjustment to
8516   // the addend is the same calculation we use for a simple
8517   // absolute relocation for the input section symbol.
8518
8519   const Symbol_value<size>* psymval = object->local_symbol(r_sym);
8520
8521   unsigned char* paddend = view + offset;
8522   typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY;
8523   switch (r_type)
8524     {
8525     case elfcpp::R_MIPS_26:
8526       reloc_status = Reloc_funcs::rel26(paddend, object, psymval,
8527           offset_in_output_section, true, 0, sh_type == elfcpp::SHT_REL, NULL,
8528           false /*TODO(sasa): cross mode jump*/, r_type, this->jal_to_bal());
8529       break;
8530
8531     default:
8532       gold_unreachable();
8533     }
8534
8535   // Report any errors.
8536   switch (reloc_status)
8537     {
8538     case Reloc_funcs::STATUS_OKAY:
8539       break;
8540     case Reloc_funcs::STATUS_OVERFLOW:
8541       gold_error_at_location(relinfo, relnum, reloc.get_r_offset(),
8542                              _("relocation overflow"));
8543       break;
8544     case Reloc_funcs::STATUS_BAD_RELOC:
8545       gold_error_at_location(relinfo, relnum, reloc.get_r_offset(),
8546         _("unexpected opcode while processing relocation"));
8547       break;
8548     default:
8549       gold_unreachable();
8550     }
8551 }
8552
8553 // Optimize the TLS relocation type based on what we know about the
8554 // symbol.  IS_FINAL is true if the final address of this symbol is
8555 // known at link time.
8556
8557 template<int size, bool big_endian>
8558 tls::Tls_optimization
8559 Target_mips<size, big_endian>::optimize_tls_reloc(bool, int)
8560 {
8561   // FIXME: Currently we do not do any TLS optimization.
8562   return tls::TLSOPT_NONE;
8563 }
8564
8565 // Scan a relocation for a local symbol.
8566
8567 template<int size, bool big_endian>
8568 inline void
8569 Target_mips<size, big_endian>::Scan::local(
8570                         Symbol_table* symtab,
8571                         Layout* layout,
8572                         Target_mips<size, big_endian>* target,
8573                         Sized_relobj_file<size, big_endian>* object,
8574                         unsigned int data_shndx,
8575                         Output_section* output_section,
8576                         const elfcpp::Rela<size, big_endian>* rela,
8577                         const elfcpp::Rel<size, big_endian>* rel,
8578                         unsigned int rel_type,
8579                         unsigned int r_type,
8580                         const elfcpp::Sym<size, big_endian>& lsym,
8581                         bool is_discarded)
8582 {
8583   if (is_discarded)
8584     return;
8585
8586   Mips_address r_offset;
8587   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
8588   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
8589
8590   if (rel_type == elfcpp::SHT_RELA)
8591     {
8592       r_offset = rela->get_r_offset();
8593       r_info = rela->get_r_info();
8594       r_addend = rela->get_r_addend();
8595     }
8596   else
8597     {
8598       r_offset = rel->get_r_offset();
8599       r_info = rel->get_r_info();
8600       r_addend = 0;
8601     }
8602
8603   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8604   Mips_relobj<size, big_endian>* mips_obj =
8605     Mips_relobj<size, big_endian>::as_mips_relobj(object);
8606
8607   if (mips_obj->is_mips16_stub_section(data_shndx))
8608     {
8609       mips_obj->get_mips16_stub_section(data_shndx)
8610               ->new_local_reloc_found(r_type, r_sym);
8611     }
8612
8613   if (r_type == elfcpp::R_MIPS_NONE)
8614     // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
8615     // mips16 stub.
8616     return;
8617
8618   if (!mips16_call_reloc(r_type)
8619       && !mips_obj->section_allows_mips16_refs(data_shndx))
8620     // This reloc would need to refer to a MIPS16 hard-float stub, if
8621     // there is one.  We ignore MIPS16 stub sections and .pdr section when
8622     // looking for relocs that would need to refer to MIPS16 stubs.
8623     mips_obj->add_local_non_16bit_call(r_sym);
8624
8625   if (r_type == elfcpp::R_MIPS16_26
8626       && !mips_obj->section_allows_mips16_refs(data_shndx))
8627     mips_obj->add_local_16bit_call(r_sym);
8628
8629   switch (r_type)
8630     {
8631     case elfcpp::R_MIPS_GOT16:
8632     case elfcpp::R_MIPS_CALL16:
8633     case elfcpp::R_MIPS_CALL_HI16:
8634     case elfcpp::R_MIPS_CALL_LO16:
8635     case elfcpp::R_MIPS_GOT_HI16:
8636     case elfcpp::R_MIPS_GOT_LO16:
8637     case elfcpp::R_MIPS_GOT_PAGE:
8638     case elfcpp::R_MIPS_GOT_OFST:
8639     case elfcpp::R_MIPS_GOT_DISP:
8640     case elfcpp::R_MIPS_TLS_GOTTPREL:
8641     case elfcpp::R_MIPS_TLS_GD:
8642     case elfcpp::R_MIPS_TLS_LDM:
8643     case elfcpp::R_MIPS16_GOT16:
8644     case elfcpp::R_MIPS16_CALL16:
8645     case elfcpp::R_MIPS16_TLS_GOTTPREL:
8646     case elfcpp::R_MIPS16_TLS_GD:
8647     case elfcpp::R_MIPS16_TLS_LDM:
8648     case elfcpp::R_MICROMIPS_GOT16:
8649     case elfcpp::R_MICROMIPS_CALL16:
8650     case elfcpp::R_MICROMIPS_CALL_HI16:
8651     case elfcpp::R_MICROMIPS_CALL_LO16:
8652     case elfcpp::R_MICROMIPS_GOT_HI16:
8653     case elfcpp::R_MICROMIPS_GOT_LO16:
8654     case elfcpp::R_MICROMIPS_GOT_PAGE:
8655     case elfcpp::R_MICROMIPS_GOT_OFST:
8656     case elfcpp::R_MICROMIPS_GOT_DISP:
8657     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8658     case elfcpp::R_MICROMIPS_TLS_GD:
8659     case elfcpp::R_MICROMIPS_TLS_LDM:
8660       // We need a GOT section.
8661       target->got_section(symtab, layout);
8662       break;
8663
8664     default:
8665       break;
8666     }
8667
8668   if (call_lo16_reloc(r_type)
8669       || got_lo16_reloc(r_type)
8670       || got_disp_reloc(r_type))
8671     {
8672       // We may need a local GOT entry for this relocation.  We
8673       // don't count R_MIPS_GOT_PAGE because we can estimate the
8674       // maximum number of pages needed by looking at the size of
8675       // the segment.  Similar comments apply to R_MIPS*_GOT16 and
8676       // R_MIPS*_CALL16.  We don't count R_MIPS_GOT_HI16, or
8677       // R_MIPS_CALL_HI16 because these are always followed by an
8678       // R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
8679       Mips_output_data_got<size, big_endian>* got =
8680         target->got_section(symtab, layout);
8681       unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8682       got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type, -1U);
8683     }
8684
8685   switch (r_type)
8686     {
8687     case elfcpp::R_MIPS_CALL16:
8688     case elfcpp::R_MIPS16_CALL16:
8689     case elfcpp::R_MICROMIPS_CALL16:
8690       gold_error(_("CALL16 reloc at 0x%lx not against global symbol "),
8691                  (unsigned long)r_offset);
8692       return;
8693
8694     case elfcpp::R_MIPS_GOT_PAGE:
8695     case elfcpp::R_MICROMIPS_GOT_PAGE:
8696     case elfcpp::R_MIPS16_GOT16:
8697     case elfcpp::R_MIPS_GOT16:
8698     case elfcpp::R_MIPS_GOT_HI16:
8699     case elfcpp::R_MIPS_GOT_LO16:
8700     case elfcpp::R_MICROMIPS_GOT16:
8701     case elfcpp::R_MICROMIPS_GOT_HI16:
8702     case elfcpp::R_MICROMIPS_GOT_LO16:
8703       {
8704         // This relocation needs a page entry in the GOT.
8705         // Get the section contents.
8706         section_size_type view_size = 0;
8707         const unsigned char* view = object->section_contents(data_shndx,
8708                                                              &view_size, false);
8709         view += r_offset;
8710
8711         Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
8712         Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff
8713                                                         : r_addend);
8714
8715         if (rel_type == elfcpp::SHT_REL && got16_reloc(r_type))
8716           target->got16_addends_.push_back(got16_addend<size, big_endian>(
8717               object, data_shndx, r_type, r_sym, addend));
8718         else
8719           target->got_section()->record_got_page_entry(mips_obj, r_sym, addend);
8720         break;
8721       }
8722
8723     case elfcpp::R_MIPS_HI16:
8724     case elfcpp::R_MIPS16_HI16:
8725     case elfcpp::R_MICROMIPS_HI16:
8726       // Record the reloc so that we can check whether the corresponding LO16
8727       // part exists.
8728       if (rel_type == elfcpp::SHT_REL)
8729         target->got16_addends_.push_back(got16_addend<size, big_endian>(
8730             object, data_shndx, r_type, r_sym, 0));
8731       break;
8732
8733     case elfcpp::R_MIPS_LO16:
8734     case elfcpp::R_MIPS16_LO16:
8735     case elfcpp::R_MICROMIPS_LO16:
8736       {
8737         if (rel_type != elfcpp::SHT_REL)
8738           break;
8739
8740         // Find corresponding GOT16/HI16 relocation.
8741
8742         // According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8743         // be immediately following.  However, for the IRIX6 ABI, the next
8744         // relocation may be a composed relocation consisting of several
8745         // relocations for the same address.  In that case, the R_MIPS_LO16
8746         // relocation may occur as one of these.  We permit a similar
8747         // extension in general, as that is useful for GCC.
8748
8749         // In some cases GCC dead code elimination removes the LO16 but
8750         // keeps the corresponding HI16.  This is strictly speaking a
8751         // violation of the ABI but not immediately harmful.
8752
8753         typename std::list<got16_addend<size, big_endian> >::iterator it =
8754           target->got16_addends_.begin();
8755         while (it != target->got16_addends_.end())
8756           {
8757             got16_addend<size, big_endian> _got16_addend = *it;
8758
8759             // TODO(sasa): Split got16_addends_ list into two lists - one for
8760             // GOT16 relocs and the other for HI16 relocs.
8761
8762             // Report an error if we find HI16 or GOT16 reloc from the
8763             // previous section without the matching LO16 part.
8764             if (_got16_addend.object != object
8765                 || _got16_addend.shndx != data_shndx)
8766               {
8767                 gold_error("Can't find matching LO16 reloc");
8768                 break;
8769               }
8770
8771             if (_got16_addend.r_sym != r_sym
8772                 || !is_matching_lo16_reloc(_got16_addend.r_type, r_type))
8773               {
8774                 ++it;
8775                 continue;
8776               }
8777
8778             // We found a matching HI16 or GOT16 reloc for this LO16 reloc.
8779             // For GOT16, we need to calculate combined addend and record GOT page
8780             // entry.
8781             if (got16_reloc(_got16_addend.r_type))
8782               {
8783
8784                 section_size_type view_size = 0;
8785                 const unsigned char* view = object->section_contents(data_shndx,
8786                                                                      &view_size,
8787                                                                      false);
8788                 view += r_offset;
8789
8790                 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
8791                 int32_t addend = Bits<16>::sign_extend32(val & 0xffff);
8792
8793                 addend = (_got16_addend.addend << 16) + addend;
8794                 target->got_section()->record_got_page_entry(mips_obj, r_sym,
8795                                                              addend);
8796               }
8797
8798             it = target->got16_addends_.erase(it);
8799           }
8800         break;
8801       }
8802     }
8803
8804   switch (r_type)
8805     {
8806     case elfcpp::R_MIPS_32:
8807     case elfcpp::R_MIPS_REL32:
8808     case elfcpp::R_MIPS_64:
8809       {
8810         if (parameters->options().output_is_position_independent())
8811           {
8812             // If building a shared library (or a position-independent
8813             // executable), we need to create a dynamic relocation for
8814             // this location.
8815             Reloc_section* rel_dyn = target->rel_dyn_section(layout);
8816             unsigned int r_sym = elfcpp::elf_r_sym<32>(r_info);
8817             rel_dyn->add_symbolless_local_addend(object, r_sym,
8818                                                  elfcpp::R_MIPS_REL32,
8819                                                  output_section, data_shndx,
8820                                                  r_offset);
8821           }
8822         break;
8823       }
8824
8825     case elfcpp::R_MIPS_TLS_GOTTPREL:
8826     case elfcpp::R_MIPS16_TLS_GOTTPREL:
8827     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8828     case elfcpp::R_MIPS_TLS_LDM:
8829     case elfcpp::R_MIPS16_TLS_LDM:
8830     case elfcpp::R_MICROMIPS_TLS_LDM:
8831     case elfcpp::R_MIPS_TLS_GD:
8832     case elfcpp::R_MIPS16_TLS_GD:
8833     case elfcpp::R_MICROMIPS_TLS_GD:
8834       {
8835         unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
8836         bool output_is_shared = parameters->options().shared();
8837         const tls::Tls_optimization optimized_type
8838             = Target_mips<size, big_endian>::optimize_tls_reloc(
8839                                              !output_is_shared, r_type);
8840         switch (r_type)
8841           {
8842           case elfcpp::R_MIPS_TLS_GD:
8843           case elfcpp::R_MIPS16_TLS_GD:
8844           case elfcpp::R_MICROMIPS_TLS_GD:
8845             if (optimized_type == tls::TLSOPT_NONE)
8846               {
8847                 // Create a pair of GOT entries for the module index and
8848                 // dtv-relative offset.
8849                 Mips_output_data_got<size, big_endian>* got =
8850                   target->got_section(symtab, layout);
8851                 unsigned int shndx = lsym.get_st_shndx();
8852                 bool is_ordinary;
8853                 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
8854                 if (!is_ordinary)
8855                   {
8856                     object->error(_("local symbol %u has bad shndx %u"),
8857                                   r_sym, shndx);
8858                     break;
8859                   }
8860                 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type,
8861                                              shndx);
8862               }
8863             else
8864               {
8865                 // FIXME: TLS optimization not supported yet.
8866                 gold_unreachable();
8867               }
8868             break;
8869
8870           case elfcpp::R_MIPS_TLS_LDM:
8871           case elfcpp::R_MIPS16_TLS_LDM:
8872           case elfcpp::R_MICROMIPS_TLS_LDM:
8873             if (optimized_type == tls::TLSOPT_NONE)
8874               {
8875                 // We always record LDM symbols as local with index 0.
8876                 target->got_section()->record_local_got_symbol(mips_obj, 0,
8877                                                                r_addend, r_type,
8878                                                                -1U);
8879               }
8880             else
8881               {
8882                 // FIXME: TLS optimization not supported yet.
8883                 gold_unreachable();
8884               }
8885             break;
8886           case elfcpp::R_MIPS_TLS_GOTTPREL:
8887           case elfcpp::R_MIPS16_TLS_GOTTPREL:
8888           case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
8889             layout->set_has_static_tls();
8890             if (optimized_type == tls::TLSOPT_NONE)
8891               {
8892                 // Create a GOT entry for the tp-relative offset.
8893                 Mips_output_data_got<size, big_endian>* got =
8894                   target->got_section(symtab, layout);
8895                 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type,
8896                                              -1U);
8897               }
8898             else
8899               {
8900                 // FIXME: TLS optimization not supported yet.
8901                 gold_unreachable();
8902               }
8903             break;
8904
8905           default:
8906             gold_unreachable();
8907         }
8908       }
8909       break;
8910
8911     default:
8912       break;
8913     }
8914
8915   // Refuse some position-dependent relocations when creating a
8916   // shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
8917   // not PIC, but we can create dynamic relocations and the result
8918   // will be fine.  Also do not refuse R_MIPS_LO16, which can be
8919   // combined with R_MIPS_GOT16.
8920   if (parameters->options().shared())
8921     {
8922       switch (r_type)
8923         {
8924         case elfcpp::R_MIPS16_HI16:
8925         case elfcpp::R_MIPS_HI16:
8926         case elfcpp::R_MICROMIPS_HI16:
8927           // Don't refuse a high part relocation if it's against
8928           // no symbol (e.g. part of a compound relocation).
8929           if (r_sym == 0)
8930             break;
8931
8932           // FALLTHROUGH
8933
8934         case elfcpp::R_MIPS16_26:
8935         case elfcpp::R_MIPS_26:
8936         case elfcpp::R_MICROMIPS_26_S1:
8937           gold_error(_("%s: relocation %u against `%s' can not be used when "
8938                        "making a shared object; recompile with -fPIC"),
8939                      object->name().c_str(), r_type, "a local symbol");
8940         default:
8941           break;
8942         }
8943     }
8944 }
8945
8946 template<int size, bool big_endian>
8947 inline void
8948 Target_mips<size, big_endian>::Scan::local(
8949                         Symbol_table* symtab,
8950                         Layout* layout,
8951                         Target_mips<size, big_endian>* target,
8952                         Sized_relobj_file<size, big_endian>* object,
8953                         unsigned int data_shndx,
8954                         Output_section* output_section,
8955                         const elfcpp::Rel<size, big_endian>& reloc,
8956                         unsigned int r_type,
8957                         const elfcpp::Sym<size, big_endian>& lsym,
8958                         bool is_discarded)
8959 {
8960   if (is_discarded)
8961     return;
8962
8963   local(
8964     symtab,
8965     layout,
8966     target,
8967     object,
8968     data_shndx,
8969     output_section,
8970     (const elfcpp::Rela<size, big_endian>*) NULL,
8971     &reloc,
8972     elfcpp::SHT_REL,
8973     r_type,
8974     lsym, is_discarded);
8975 }
8976
8977
8978 template<int size, bool big_endian>
8979 inline void
8980 Target_mips<size, big_endian>::Scan::local(
8981                         Symbol_table* symtab,
8982                         Layout* layout,
8983                         Target_mips<size, big_endian>* target,
8984                         Sized_relobj_file<size, big_endian>* object,
8985                         unsigned int data_shndx,
8986                         Output_section* output_section,
8987                         const elfcpp::Rela<size, big_endian>& reloc,
8988                         unsigned int r_type,
8989                         const elfcpp::Sym<size, big_endian>& lsym,
8990                         bool is_discarded)
8991 {
8992   if (is_discarded)
8993     return;
8994
8995   local(
8996     symtab,
8997     layout,
8998     target,
8999     object,
9000     data_shndx,
9001     output_section,
9002     &reloc,
9003     (const elfcpp::Rel<size, big_endian>*) NULL,
9004     elfcpp::SHT_RELA,
9005     r_type,
9006     lsym, is_discarded);
9007 }
9008
9009 // Scan a relocation for a global symbol.
9010
9011 template<int size, bool big_endian>
9012 inline void
9013 Target_mips<size, big_endian>::Scan::global(
9014                                 Symbol_table* symtab,
9015                                 Layout* layout,
9016                                 Target_mips<size, big_endian>* target,
9017                                 Sized_relobj_file<size, big_endian>* object,
9018                                 unsigned int data_shndx,
9019                                 Output_section* output_section,
9020                                 const elfcpp::Rela<size, big_endian>* rela,
9021                                 const elfcpp::Rel<size, big_endian>* rel,
9022                                 unsigned int rel_type,
9023                                 unsigned int r_type,
9024                                 Symbol* gsym)
9025 {
9026   Mips_address r_offset;
9027   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
9028   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
9029
9030   if (rel_type == elfcpp::SHT_RELA)
9031     {
9032       r_offset = rela->get_r_offset();
9033       r_info = rela->get_r_info();
9034       r_addend = rela->get_r_addend();
9035     }
9036   else
9037     {
9038       r_offset = rel->get_r_offset();
9039       r_info = rel->get_r_info();
9040       r_addend = 0;
9041     }
9042
9043   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
9044   Mips_relobj<size, big_endian>* mips_obj =
9045     Mips_relobj<size, big_endian>::as_mips_relobj(object);
9046   Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
9047
9048   if (mips_obj->is_mips16_stub_section(data_shndx))
9049     {
9050       mips_obj->get_mips16_stub_section(data_shndx)
9051               ->new_global_reloc_found(r_type, mips_sym);
9052     }
9053
9054   if (r_type == elfcpp::R_MIPS_NONE)
9055     // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
9056     // mips16 stub.
9057     return;
9058
9059   if (!mips16_call_reloc(r_type)
9060       && !mips_obj->section_allows_mips16_refs(data_shndx))
9061     // This reloc would need to refer to a MIPS16 hard-float stub, if
9062     // there is one.  We ignore MIPS16 stub sections and .pdr section when
9063     // looking for relocs that would need to refer to MIPS16 stubs.
9064     mips_sym->set_need_fn_stub();
9065
9066   // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
9067   // section.  We check here to avoid creating a dynamic reloc against
9068   // _GLOBAL_OFFSET_TABLE_.
9069   if (!target->has_got_section()
9070       && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
9071     target->got_section(symtab, layout);
9072
9073   // We need PLT entries if there are static-only relocations against
9074   // an externally-defined function.  This can technically occur for
9075   // shared libraries if there are branches to the symbol, although it
9076   // is unlikely that this will be used in practice due to the short
9077   // ranges involved.  It can occur for any relative or absolute relocation
9078   // in executables; in that case, the PLT entry becomes the function's
9079   // canonical address.
9080   bool static_reloc = false;
9081
9082   // Set CAN_MAKE_DYNAMIC to true if we can convert this
9083   // relocation into a dynamic one.
9084   bool can_make_dynamic = false;
9085   switch (r_type)
9086     {
9087     case elfcpp::R_MIPS_GOT16:
9088     case elfcpp::R_MIPS_CALL16:
9089     case elfcpp::R_MIPS_CALL_HI16:
9090     case elfcpp::R_MIPS_CALL_LO16:
9091     case elfcpp::R_MIPS_GOT_HI16:
9092     case elfcpp::R_MIPS_GOT_LO16:
9093     case elfcpp::R_MIPS_GOT_PAGE:
9094     case elfcpp::R_MIPS_GOT_OFST:
9095     case elfcpp::R_MIPS_GOT_DISP:
9096     case elfcpp::R_MIPS_TLS_GOTTPREL:
9097     case elfcpp::R_MIPS_TLS_GD:
9098     case elfcpp::R_MIPS_TLS_LDM:
9099     case elfcpp::R_MIPS16_GOT16:
9100     case elfcpp::R_MIPS16_CALL16:
9101     case elfcpp::R_MIPS16_TLS_GOTTPREL:
9102     case elfcpp::R_MIPS16_TLS_GD:
9103     case elfcpp::R_MIPS16_TLS_LDM:
9104     case elfcpp::R_MICROMIPS_GOT16:
9105     case elfcpp::R_MICROMIPS_CALL16:
9106     case elfcpp::R_MICROMIPS_CALL_HI16:
9107     case elfcpp::R_MICROMIPS_CALL_LO16:
9108     case elfcpp::R_MICROMIPS_GOT_HI16:
9109     case elfcpp::R_MICROMIPS_GOT_LO16:
9110     case elfcpp::R_MICROMIPS_GOT_PAGE:
9111     case elfcpp::R_MICROMIPS_GOT_OFST:
9112     case elfcpp::R_MICROMIPS_GOT_DISP:
9113     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9114     case elfcpp::R_MICROMIPS_TLS_GD:
9115     case elfcpp::R_MICROMIPS_TLS_LDM:
9116       // We need a GOT section.
9117       target->got_section(symtab, layout);
9118       break;
9119
9120     // This is just a hint; it can safely be ignored.  Don't set
9121     // has_static_relocs for the corresponding symbol.
9122     case elfcpp::R_MIPS_JALR:
9123     case elfcpp::R_MICROMIPS_JALR:
9124       break;
9125
9126     case elfcpp::R_MIPS_GPREL16:
9127     case elfcpp::R_MIPS_GPREL32:
9128     case elfcpp::R_MIPS16_GPREL:
9129     case elfcpp::R_MICROMIPS_GPREL16:
9130       // TODO(sasa)
9131       // GP-relative relocations always resolve to a definition in a
9132       // regular input file, ignoring the one-definition rule.  This is
9133       // important for the GP setup sequence in NewABI code, which
9134       // always resolves to a local function even if other relocations
9135       // against the symbol wouldn't.
9136       //constrain_symbol_p = FALSE;
9137       break;
9138
9139     case elfcpp::R_MIPS_32:
9140     case elfcpp::R_MIPS_REL32:
9141     case elfcpp::R_MIPS_64:
9142       if (parameters->options().shared()
9143           || strcmp(gsym->name(), "__gnu_local_gp") != 0)
9144         {
9145           if (r_type != elfcpp::R_MIPS_REL32)
9146             {
9147               static_reloc = true;
9148               mips_sym->set_pointer_equality_needed();
9149             }
9150           can_make_dynamic = true;
9151           break;
9152         }
9153       // Fall through.
9154
9155     default:
9156       // Most static relocations require pointer equality, except
9157       // for branches.
9158       mips_sym->set_pointer_equality_needed();
9159
9160       // Fall through.
9161
9162     case elfcpp::R_MIPS_26:
9163     case elfcpp::R_MIPS_PC16:
9164     case elfcpp::R_MIPS16_26:
9165     case elfcpp::R_MICROMIPS_26_S1:
9166     case elfcpp::R_MICROMIPS_PC7_S1:
9167     case elfcpp::R_MICROMIPS_PC10_S1:
9168     case elfcpp::R_MICROMIPS_PC16_S1:
9169     case elfcpp::R_MICROMIPS_PC23_S2:
9170       static_reloc = true;
9171       mips_sym->set_has_static_relocs();
9172       break;
9173     }
9174
9175   // If there are call relocations against an externally-defined symbol,
9176   // see whether we can create a MIPS lazy-binding stub for it.  We can
9177   // only do this if all references to the function are through call
9178   // relocations, and in that case, the traditional lazy-binding stubs
9179   // are much more efficient than PLT entries.
9180   switch (r_type)
9181     {
9182     case elfcpp::R_MIPS16_CALL16:
9183     case elfcpp::R_MIPS_CALL16:
9184     case elfcpp::R_MIPS_CALL_HI16:
9185     case elfcpp::R_MIPS_CALL_LO16:
9186     case elfcpp::R_MIPS_JALR:
9187     case elfcpp::R_MICROMIPS_CALL16:
9188     case elfcpp::R_MICROMIPS_CALL_HI16:
9189     case elfcpp::R_MICROMIPS_CALL_LO16:
9190     case elfcpp::R_MICROMIPS_JALR:
9191       if (!mips_sym->no_lazy_stub())
9192         {
9193           if ((mips_sym->needs_plt_entry() && mips_sym->is_from_dynobj())
9194               // Calls from shared objects to undefined symbols of type
9195               // STT_NOTYPE need lazy-binding stub.
9196               || (mips_sym->is_undefined() && parameters->options().shared()))
9197             target->mips_stubs_section(layout)->make_entry(mips_sym);
9198         }
9199       break;
9200     default:
9201       {
9202         // We must not create a stub for a symbol that has relocations
9203         // related to taking the function's address.
9204         mips_sym->set_no_lazy_stub();
9205         target->remove_lazy_stub_entry(mips_sym);
9206         break;
9207       }
9208   }
9209
9210   if (relocation_needs_la25_stub<size, big_endian>(mips_obj, r_type,
9211                                                    mips_sym->is_mips16()))
9212     mips_sym->set_has_nonpic_branches();
9213
9214   // R_MIPS_HI16 against _gp_disp is used for $gp setup,
9215   // and has a special meaning.
9216   bool gp_disp_against_hi16 = (!mips_obj->is_newabi()
9217                                && strcmp(gsym->name(), "_gp_disp") == 0
9218                                && (hi16_reloc(r_type) || lo16_reloc(r_type)));
9219   if (static_reloc && gsym->needs_plt_entry())
9220     {
9221       target->make_plt_entry(symtab, layout, mips_sym, r_type);
9222
9223       // Since this is not a PC-relative relocation, we may be
9224       // taking the address of a function.  In that case we need to
9225       // set the entry in the dynamic symbol table to the address of
9226       // the PLT entry.
9227       if (gsym->is_from_dynobj() && !parameters->options().shared())
9228         {
9229           gsym->set_needs_dynsym_value();
9230           // We distinguish between PLT entries and lazy-binding stubs by
9231           // giving the former an st_other value of STO_MIPS_PLT.  Set the
9232           // flag if there are any relocations in the binary where pointer
9233           // equality matters.
9234           if (mips_sym->pointer_equality_needed())
9235             mips_sym->set_mips_plt();
9236         }
9237     }
9238   if ((static_reloc || can_make_dynamic) && !gp_disp_against_hi16)
9239     {
9240       // Absolute addressing relocations.
9241       // Make a dynamic relocation if necessary.
9242       if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
9243         {
9244           if (gsym->may_need_copy_reloc())
9245             {
9246               target->copy_reloc(symtab, layout, object,
9247                                  data_shndx, output_section, gsym, *rel);
9248             }
9249           else if (can_make_dynamic)
9250             {
9251               // Create .rel.dyn section.
9252               target->rel_dyn_section(layout);
9253               target->dynamic_reloc(mips_sym, elfcpp::R_MIPS_REL32, mips_obj,
9254                                     data_shndx, output_section, r_offset);
9255             }
9256           else
9257             gold_error(_("non-dynamic relocations refer to dynamic symbol %s"),
9258                        gsym->name());
9259         }
9260     }
9261
9262   bool for_call = false;
9263   switch (r_type)
9264     {
9265     case elfcpp::R_MIPS_CALL16:
9266     case elfcpp::R_MIPS16_CALL16:
9267     case elfcpp::R_MICROMIPS_CALL16:
9268     case elfcpp::R_MIPS_CALL_HI16:
9269     case elfcpp::R_MIPS_CALL_LO16:
9270     case elfcpp::R_MICROMIPS_CALL_HI16:
9271     case elfcpp::R_MICROMIPS_CALL_LO16:
9272       for_call = true;
9273       // Fall through.
9274
9275     case elfcpp::R_MIPS16_GOT16:
9276     case elfcpp::R_MIPS_GOT16:
9277     case elfcpp::R_MIPS_GOT_HI16:
9278     case elfcpp::R_MIPS_GOT_LO16:
9279     case elfcpp::R_MICROMIPS_GOT16:
9280     case elfcpp::R_MICROMIPS_GOT_HI16:
9281     case elfcpp::R_MICROMIPS_GOT_LO16:
9282     case elfcpp::R_MIPS_GOT_DISP:
9283     case elfcpp::R_MICROMIPS_GOT_DISP:
9284       {
9285         // The symbol requires a GOT entry.
9286         Mips_output_data_got<size, big_endian>* got =
9287           target->got_section(symtab, layout);
9288         got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9289                                       for_call);
9290         mips_sym->set_global_got_area(GGA_NORMAL);
9291       }
9292       break;
9293
9294     case elfcpp::R_MIPS_GOT_PAGE:
9295     case elfcpp::R_MICROMIPS_GOT_PAGE:
9296       {
9297         // This relocation needs a page entry in the GOT.
9298         // Get the section contents.
9299         section_size_type view_size = 0;
9300         const unsigned char* view =
9301           object->section_contents(data_shndx, &view_size, false);
9302         view += r_offset;
9303
9304         Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view);
9305         Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff
9306                                                         : r_addend);
9307         Mips_output_data_got<size, big_endian>* got =
9308           target->got_section(symtab, layout);
9309         got->record_got_page_entry(mips_obj, r_sym, addend);
9310
9311         // If this is a global, overridable symbol, GOT_PAGE will
9312         // decay to GOT_DISP, so we'll need a GOT entry for it.
9313         bool def_regular = (mips_sym->source() == Symbol::FROM_OBJECT
9314                             && !mips_sym->object()->is_dynamic()
9315                             && !mips_sym->is_undefined());
9316         if (!def_regular
9317             || (parameters->options().output_is_position_independent()
9318                 && !parameters->options().Bsymbolic()
9319                 && !mips_sym->is_forced_local()))
9320           {
9321             got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9322                                           for_call);
9323             mips_sym->set_global_got_area(GGA_NORMAL);
9324           }
9325       }
9326       break;
9327
9328     case elfcpp::R_MIPS_TLS_GOTTPREL:
9329     case elfcpp::R_MIPS16_TLS_GOTTPREL:
9330     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9331     case elfcpp::R_MIPS_TLS_LDM:
9332     case elfcpp::R_MIPS16_TLS_LDM:
9333     case elfcpp::R_MICROMIPS_TLS_LDM:
9334     case elfcpp::R_MIPS_TLS_GD:
9335     case elfcpp::R_MIPS16_TLS_GD:
9336     case elfcpp::R_MICROMIPS_TLS_GD:
9337       {
9338         const bool is_final = gsym->final_value_is_known();
9339         const tls::Tls_optimization optimized_type =
9340           Target_mips<size, big_endian>::optimize_tls_reloc(is_final, r_type);
9341
9342         switch (r_type)
9343           {
9344           case elfcpp::R_MIPS_TLS_GD:
9345           case elfcpp::R_MIPS16_TLS_GD:
9346           case elfcpp::R_MICROMIPS_TLS_GD:
9347             if (optimized_type == tls::TLSOPT_NONE)
9348               {
9349                 // Create a pair of GOT entries for the module index and
9350                 // dtv-relative offset.
9351                 Mips_output_data_got<size, big_endian>* got =
9352                   target->got_section(symtab, layout);
9353                 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9354                                               false);
9355               }
9356             else
9357               {
9358                 // FIXME: TLS optimization not supported yet.
9359                 gold_unreachable();
9360               }
9361             break;
9362
9363           case elfcpp::R_MIPS_TLS_LDM:
9364           case elfcpp::R_MIPS16_TLS_LDM:
9365           case elfcpp::R_MICROMIPS_TLS_LDM:
9366             if (optimized_type == tls::TLSOPT_NONE)
9367               {
9368                 // We always record LDM symbols as local with index 0.
9369                 target->got_section()->record_local_got_symbol(mips_obj, 0,
9370                                                                r_addend, r_type,
9371                                                                -1U);
9372               }
9373             else
9374               {
9375                 // FIXME: TLS optimization not supported yet.
9376                 gold_unreachable();
9377               }
9378             break;
9379           case elfcpp::R_MIPS_TLS_GOTTPREL:
9380           case elfcpp::R_MIPS16_TLS_GOTTPREL:
9381           case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
9382             layout->set_has_static_tls();
9383             if (optimized_type == tls::TLSOPT_NONE)
9384               {
9385                 // Create a GOT entry for the tp-relative offset.
9386                 Mips_output_data_got<size, big_endian>* got =
9387                   target->got_section(symtab, layout);
9388                 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false,
9389                                               false);
9390               }
9391             else
9392               {
9393                 // FIXME: TLS optimization not supported yet.
9394                 gold_unreachable();
9395               }
9396             break;
9397
9398           default:
9399             gold_unreachable();
9400         }
9401       }
9402       break;
9403     case elfcpp::R_MIPS_COPY:
9404     case elfcpp::R_MIPS_JUMP_SLOT:
9405       // These are relocations which should only be seen by the
9406       // dynamic linker, and should never be seen here.
9407       gold_error(_("%s: unexpected reloc %u in object file"),
9408                  object->name().c_str(), r_type);
9409       break;
9410
9411     default:
9412       break;
9413     }
9414
9415   // Refuse some position-dependent relocations when creating a
9416   // shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
9417   // not PIC, but we can create dynamic relocations and the result
9418   // will be fine.  Also do not refuse R_MIPS_LO16, which can be
9419   // combined with R_MIPS_GOT16.
9420   if (parameters->options().shared())
9421     {
9422       switch (r_type)
9423         {
9424         case elfcpp::R_MIPS16_HI16:
9425         case elfcpp::R_MIPS_HI16:
9426         case elfcpp::R_MICROMIPS_HI16:
9427           // Don't refuse a high part relocation if it's against
9428           // no symbol (e.g. part of a compound relocation).
9429           if (r_sym == 0)
9430             break;
9431
9432           // R_MIPS_HI16 against _gp_disp is used for $gp setup,
9433           // and has a special meaning.
9434           if (!mips_obj->is_newabi() && strcmp(gsym->name(), "_gp_disp") == 0)
9435             break;
9436
9437           // FALLTHROUGH
9438
9439         case elfcpp::R_MIPS16_26:
9440         case elfcpp::R_MIPS_26:
9441         case elfcpp::R_MICROMIPS_26_S1:
9442           gold_error(_("%s: relocation %u against `%s' can not be used when "
9443                        "making a shared object; recompile with -fPIC"),
9444                      object->name().c_str(), r_type, gsym->name());
9445         default:
9446           break;
9447         }
9448     }
9449 }
9450
9451 template<int size, bool big_endian>
9452 inline void
9453 Target_mips<size, big_endian>::Scan::global(
9454                                 Symbol_table* symtab,
9455                                 Layout* layout,
9456                                 Target_mips<size, big_endian>* target,
9457                                 Sized_relobj_file<size, big_endian>* object,
9458                                 unsigned int data_shndx,
9459                                 Output_section* output_section,
9460                                 const elfcpp::Rela<size, big_endian>& reloc,
9461                                 unsigned int r_type,
9462                                 Symbol* gsym)
9463 {
9464   global(
9465     symtab,
9466     layout,
9467     target,
9468     object,
9469     data_shndx,
9470     output_section,
9471     &reloc,
9472     (const elfcpp::Rel<size, big_endian>*) NULL,
9473     elfcpp::SHT_RELA,
9474     r_type,
9475     gsym);
9476 }
9477
9478 template<int size, bool big_endian>
9479 inline void
9480 Target_mips<size, big_endian>::Scan::global(
9481                                 Symbol_table* symtab,
9482                                 Layout* layout,
9483                                 Target_mips<size, big_endian>* target,
9484                                 Sized_relobj_file<size, big_endian>* object,
9485                                 unsigned int data_shndx,
9486                                 Output_section* output_section,
9487                                 const elfcpp::Rel<size, big_endian>& reloc,
9488                                 unsigned int r_type,
9489                                 Symbol* gsym)
9490 {
9491   global(
9492     symtab,
9493     layout,
9494     target,
9495     object,
9496     data_shndx,
9497     output_section,
9498     (const elfcpp::Rela<size, big_endian>*) NULL,
9499     &reloc,
9500     elfcpp::SHT_REL,
9501     r_type,
9502     gsym);
9503 }
9504
9505 // Return whether a R_MIPS_32 relocation needs to be applied.
9506
9507 template<int size, bool big_endian>
9508 inline bool
9509 Target_mips<size, big_endian>::Relocate::should_apply_r_mips_32_reloc(
9510     const Mips_symbol<size>* gsym,
9511     unsigned int r_type,
9512     Output_section* output_section,
9513     Target_mips* target)
9514 {
9515   // If the output section is not allocated, then we didn't call
9516   // scan_relocs, we didn't create a dynamic reloc, and we must apply
9517   // the reloc here.
9518   if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0)
9519       return true;
9520
9521   if (gsym == NULL)
9522     return true;
9523   else
9524     {
9525       // For global symbols, we use the same helper routines used in the
9526       // scan pass.
9527       if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))
9528           && !gsym->may_need_copy_reloc())
9529         {
9530           // We have generated dynamic reloc (R_MIPS_REL32).
9531
9532           bool multi_got = false;
9533           if (target->has_got_section())
9534             multi_got = target->got_section()->multi_got();
9535           bool has_got_offset;
9536           if (!multi_got)
9537             has_got_offset = gsym->has_got_offset(GOT_TYPE_STANDARD);
9538           else
9539             has_got_offset = gsym->global_gotoffset() != -1U;
9540           if (!has_got_offset)
9541             return true;
9542           else
9543             // Apply the relocation only if the symbol is in the local got.
9544             // Do not apply the relocation if the symbol is in the global
9545             // got.
9546             return symbol_references_local(gsym, gsym->has_dynsym_index());
9547         }
9548       else
9549         // We have not generated dynamic reloc.
9550         return true;
9551     }
9552 }
9553
9554 // Perform a relocation.
9555
9556 template<int size, bool big_endian>
9557 inline bool
9558 Target_mips<size, big_endian>::Relocate::relocate(
9559                         const Relocate_info<size, big_endian>* relinfo,
9560                         Target_mips* target,
9561                         Output_section* output_section,
9562                         size_t relnum,
9563                         const elfcpp::Rela<size, big_endian>* rela,
9564                         const elfcpp::Rel<size, big_endian>* rel,
9565                         unsigned int rel_type,
9566                         unsigned int r_type,
9567                         const Sized_symbol<size>* gsym,
9568                         const Symbol_value<size>* psymval,
9569                         unsigned char* view,
9570                         Mips_address address,
9571                         section_size_type)
9572 {
9573   Mips_address r_offset;
9574   typename elfcpp::Elf_types<size>::Elf_WXword r_info;
9575   typename elfcpp::Elf_types<size>::Elf_Swxword r_addend;
9576
9577   if (rel_type == elfcpp::SHT_RELA)
9578     {
9579       r_offset = rela->get_r_offset();
9580       r_info = rela->get_r_info();
9581       r_addend = rela->get_r_addend();
9582     }
9583   else
9584     {
9585       r_offset = rel->get_r_offset();
9586       r_info = rel->get_r_info();
9587       r_addend = 0;
9588     }
9589
9590   typedef Mips_relocate_functions<size, big_endian> Reloc_funcs;
9591   typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY;
9592
9593   Mips_relobj<size, big_endian>* object =
9594     Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object);
9595
9596   unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
9597   bool target_is_16_bit_code = false;
9598   bool target_is_micromips_code = false;
9599   bool cross_mode_jump;
9600
9601   Symbol_value<size> symval;
9602
9603   const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym);
9604
9605   bool changed_symbol_value = false;
9606   if (gsym == NULL)
9607     {
9608       target_is_16_bit_code = object->local_symbol_is_mips16(r_sym);
9609       target_is_micromips_code = object->local_symbol_is_micromips(r_sym);
9610       if (target_is_16_bit_code || target_is_micromips_code)
9611         {
9612           // MIPS16/microMIPS text labels should be treated as odd.
9613           symval.set_output_value(psymval->value(object, 1));
9614           psymval = &symval;
9615           changed_symbol_value = true;
9616         }
9617     }
9618   else
9619     {
9620       target_is_16_bit_code = mips_sym->is_mips16();
9621       target_is_micromips_code = mips_sym->is_micromips();
9622
9623       // If this is a mips16/microMIPS text symbol, add 1 to the value to make
9624       // it odd.  This will cause something like .word SYM to come up with
9625       // the right value when it is loaded into the PC.
9626
9627       if ((mips_sym->is_mips16() || mips_sym->is_micromips())
9628           && psymval->value(object, 0) != 0)
9629         {
9630           symval.set_output_value(psymval->value(object, 0) | 1);
9631           psymval = &symval;
9632           changed_symbol_value = true;
9633         }
9634
9635       // Pick the value to use for symbols defined in shared objects.
9636       if (mips_sym->use_plt_offset(Scan::get_reference_flags(r_type))
9637           || mips_sym->has_lazy_stub())
9638         {
9639           Mips_address value;
9640           if (!mips_sym->has_lazy_stub())
9641             {
9642               // Prefer a standard MIPS PLT entry.
9643               if (mips_sym->has_mips_plt_offset())
9644                 {
9645                   value = target->plt_section()->mips_entry_address(mips_sym);
9646                   target_is_micromips_code = false;
9647                   target_is_16_bit_code = false;
9648                 }
9649               else
9650                 {
9651                   value = (target->plt_section()->comp_entry_address(mips_sym)
9652                            + 1);
9653                   if (target->is_output_micromips())
9654                     target_is_micromips_code = true;
9655                   else
9656                     target_is_16_bit_code = true;
9657                 }
9658             }
9659           else
9660             value = target->mips_stubs_section()->stub_address(mips_sym);
9661
9662           symval.set_output_value(value);
9663           psymval = &symval;
9664         }
9665     }
9666
9667   // TRUE if the symbol referred to by this relocation is "_gp_disp".
9668   // Note that such a symbol must always be a global symbol.
9669   bool gp_disp = (gsym != NULL && (strcmp(gsym->name(), "_gp_disp") == 0)
9670                   && !object->is_newabi());
9671
9672   // TRUE if the symbol referred to by this relocation is "__gnu_local_gp".
9673   // Note that such a symbol must always be a global symbol.
9674   bool gnu_local_gp = gsym && (strcmp(gsym->name(), "__gnu_local_gp") == 0);
9675
9676
9677   if (gp_disp)
9678     {
9679       if (!hi16_reloc(r_type) && !lo16_reloc(r_type))
9680         gold_error_at_location(relinfo, relnum, r_offset,
9681           _("relocations against _gp_disp are permitted only"
9682             " with R_MIPS_HI16 and R_MIPS_LO16 relocations."));
9683     }
9684   else if (gnu_local_gp)
9685     {
9686       // __gnu_local_gp is _gp symbol.
9687       symval.set_output_value(target->adjusted_gp_value(object));
9688       psymval = &symval;
9689     }
9690
9691   // If this is a reference to a 16-bit function with a stub, we need
9692   // to redirect the relocation to the stub unless:
9693   //
9694   // (a) the relocation is for a MIPS16 JAL;
9695   //
9696   // (b) the relocation is for a MIPS16 PIC call, and there are no
9697   //     non-MIPS16 uses of the GOT slot; or
9698   //
9699   // (c) the section allows direct references to MIPS16 functions.
9700   if (r_type != elfcpp::R_MIPS16_26
9701       && !parameters->options().relocatable()
9702       && ((mips_sym != NULL
9703            && mips_sym->has_mips16_fn_stub()
9704            && (r_type != elfcpp::R_MIPS16_CALL16 || mips_sym->need_fn_stub()))
9705           || (mips_sym == NULL
9706               && object->get_local_mips16_fn_stub(r_sym) != NULL))
9707       && !object->section_allows_mips16_refs(relinfo->data_shndx))
9708     {
9709       // This is a 32- or 64-bit call to a 16-bit function.  We should
9710       // have already noticed that we were going to need the
9711       // stub.
9712       Mips_address value;
9713       if (mips_sym == NULL)
9714         value = object->get_local_mips16_fn_stub(r_sym)->output_address();
9715       else
9716         {
9717           gold_assert(mips_sym->need_fn_stub());
9718           if (mips_sym->has_la25_stub())
9719             value = target->la25_stub_section()->stub_address(mips_sym);
9720           else
9721             {
9722               value = mips_sym->template
9723                       get_mips16_fn_stub<big_endian>()->output_address();
9724             }
9725           }
9726       symval.set_output_value(value);
9727       psymval = &symval;
9728       changed_symbol_value = true;
9729
9730       // The target is 16-bit, but the stub isn't.
9731       target_is_16_bit_code = false;
9732     }
9733   // If this is a MIPS16 call with a stub, that is made through the PLT or
9734   // to a standard MIPS function, we need to redirect the call to the stub.
9735   // Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
9736   // indirect calls should use an indirect stub instead.
9737   else if (r_type == elfcpp::R_MIPS16_26 && !parameters->options().relocatable()
9738            && ((mips_sym != NULL
9739                 && (mips_sym->has_mips16_call_stub()
9740                     || mips_sym->has_mips16_call_fp_stub()))
9741                || (mips_sym == NULL
9742                    && object->get_local_mips16_call_stub(r_sym) != NULL))
9743            && ((mips_sym != NULL && mips_sym->has_plt_offset())
9744                || !target_is_16_bit_code))
9745     {
9746       Mips16_stub_section<size, big_endian>* call_stub;
9747       if (mips_sym == NULL)
9748         call_stub = object->get_local_mips16_call_stub(r_sym);
9749       else
9750         {
9751           // If both call_stub and call_fp_stub are defined, we can figure
9752           // out which one to use by checking which one appears in the input
9753           // file.
9754           if (mips_sym->has_mips16_call_stub()
9755               && mips_sym->has_mips16_call_fp_stub())
9756             {
9757               call_stub = NULL;
9758               for (unsigned int i = 1; i < object->shnum(); ++i)
9759                 {
9760                   if (object->is_mips16_call_fp_stub_section(i))
9761                     {
9762                       call_stub = mips_sym->template
9763                                   get_mips16_call_fp_stub<big_endian>();
9764                       break;
9765                     }
9766
9767                 }
9768               if (call_stub == NULL)
9769                 call_stub =
9770                   mips_sym->template get_mips16_call_stub<big_endian>();
9771             }
9772           else if (mips_sym->has_mips16_call_stub())
9773             call_stub = mips_sym->template get_mips16_call_stub<big_endian>();
9774           else
9775             call_stub = mips_sym->template get_mips16_call_fp_stub<big_endian>();
9776         }
9777
9778       symval.set_output_value(call_stub->output_address());
9779       psymval = &symval;
9780       changed_symbol_value = true;
9781     }
9782   // If this is a direct call to a PIC function, redirect to the
9783   // non-PIC stub.
9784   else if (mips_sym != NULL
9785            && mips_sym->has_la25_stub()
9786            && relocation_needs_la25_stub<size, big_endian>(
9787                                        object, r_type, target_is_16_bit_code))
9788     {
9789       Mips_address value = target->la25_stub_section()->stub_address(mips_sym);
9790       if (mips_sym->is_micromips())
9791         value += 1;
9792       symval.set_output_value(value);
9793       psymval = &symval;
9794     }
9795   // For direct MIPS16 and microMIPS calls make sure the compressed PLT
9796   // entry is used if a standard PLT entry has also been made.
9797   else if ((r_type == elfcpp::R_MIPS16_26
9798             || r_type == elfcpp::R_MICROMIPS_26_S1)
9799           && !parameters->options().relocatable()
9800           && mips_sym != NULL
9801           && mips_sym->has_plt_offset()
9802           && mips_sym->has_comp_plt_offset()
9803           && mips_sym->has_mips_plt_offset())
9804     {
9805       Mips_address value = (target->plt_section()->comp_entry_address(mips_sym)
9806                             + 1);
9807       symval.set_output_value(value);
9808       psymval = &symval;
9809
9810       target_is_16_bit_code = !target->is_output_micromips();
9811       target_is_micromips_code = target->is_output_micromips();
9812     }
9813
9814   // Make sure MIPS16 and microMIPS are not used together.
9815   if ((r_type == elfcpp::R_MIPS16_26 && target_is_micromips_code)
9816       || (micromips_branch_reloc(r_type) && target_is_16_bit_code))
9817    {
9818       gold_error(_("MIPS16 and microMIPS functions cannot call each other"));
9819    }
9820
9821   // Calls from 16-bit code to 32-bit code and vice versa require the
9822   // mode change.  However, we can ignore calls to undefined weak symbols,
9823   // which should never be executed at runtime.  This exception is important
9824   // because the assembly writer may have "known" that any definition of the
9825   // symbol would be 16-bit code, and that direct jumps were therefore
9826   // acceptable.
9827   cross_mode_jump =
9828     (!parameters->options().relocatable()
9829      && !(gsym != NULL && gsym->is_weak_undefined())
9830      && ((r_type == elfcpp::R_MIPS16_26 && !target_is_16_bit_code)
9831          || (r_type == elfcpp::R_MICROMIPS_26_S1 && !target_is_micromips_code)
9832          || ((r_type == elfcpp::R_MIPS_26 || r_type == elfcpp::R_MIPS_JALR)
9833              && (target_is_16_bit_code || target_is_micromips_code))));
9834
9835   bool local = (mips_sym == NULL
9836                 || (mips_sym->got_only_for_calls()
9837                     ? symbol_calls_local(mips_sym, mips_sym->has_dynsym_index())
9838                     : symbol_references_local(mips_sym,
9839                                               mips_sym->has_dynsym_index())));
9840
9841   // Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
9842   // to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
9843   // corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.
9844   if (got_page_reloc(r_type) && !local)
9845     r_type = (micromips_reloc(r_type) ? elfcpp::R_MICROMIPS_GOT_DISP
9846                                       : elfcpp::R_MIPS_GOT_DISP);
9847
9848   unsigned int got_offset = 0;
9849   int gp_offset = 0;
9850
9851   bool update_got_entry = false;
9852   bool extract_addend = rel_type == elfcpp::SHT_REL;
9853   switch (r_type)
9854     {
9855     case elfcpp::R_MIPS_NONE:
9856       break;
9857     case elfcpp::R_MIPS_16:
9858       reloc_status = Reloc_funcs::rel16(view, object, psymval, r_addend,
9859                                         extract_addend, r_type);
9860       break;
9861
9862     case elfcpp::R_MIPS_32:
9863       if (should_apply_r_mips_32_reloc(mips_sym, r_type, output_section,
9864                                        target))
9865         reloc_status = Reloc_funcs::rel32(view, object, psymval, r_addend,
9866                                           extract_addend, r_type);
9867       if (mips_sym != NULL
9868           && (mips_sym->is_mips16() || mips_sym->is_micromips())
9869           && mips_sym->global_got_area() == GGA_RELOC_ONLY)
9870         {
9871           // If mips_sym->has_mips16_fn_stub() is false, symbol value is
9872           // already updated by adding +1.
9873           if (mips_sym->has_mips16_fn_stub())
9874             {
9875               gold_assert(mips_sym->need_fn_stub());
9876               Mips16_stub_section<size, big_endian>* fn_stub =
9877                 mips_sym->template get_mips16_fn_stub<big_endian>();
9878
9879               symval.set_output_value(fn_stub->output_address());
9880               psymval = &symval;
9881             }
9882           got_offset = mips_sym->global_gotoffset();
9883           update_got_entry = true;
9884         }
9885       break;
9886
9887     case elfcpp::R_MIPS_REL32:
9888       gold_unreachable();
9889
9890     case elfcpp::R_MIPS_PC32:
9891       reloc_status = Reloc_funcs::relpc32(view, object, psymval, address,
9892                                           r_addend, extract_addend, r_type);
9893       break;
9894
9895     case elfcpp::R_MIPS16_26:
9896       // The calculation for R_MIPS16_26 is just the same as for an
9897       // R_MIPS_26.  It's only the storage of the relocated field into
9898       // the output file that's different.  So, we just fall through to the
9899       // R_MIPS_26 case here.
9900     case elfcpp::R_MIPS_26:
9901     case elfcpp::R_MICROMIPS_26_S1:
9902       reloc_status = Reloc_funcs::rel26(view, object, psymval, address,
9903           gsym == NULL, r_addend, extract_addend, gsym, cross_mode_jump, r_type,
9904           target->jal_to_bal());
9905       break;
9906
9907     case elfcpp::R_MIPS_HI16:
9908     case elfcpp::R_MIPS16_HI16:
9909     case elfcpp::R_MICROMIPS_HI16:
9910       reloc_status = Reloc_funcs::relhi16(view, object, psymval, r_addend,
9911                                           address, gp_disp, r_type,
9912                                           extract_addend);
9913       break;
9914
9915     case elfcpp::R_MIPS_LO16:
9916     case elfcpp::R_MIPS16_LO16:
9917     case elfcpp::R_MICROMIPS_LO16:
9918     case elfcpp::R_MICROMIPS_HI0_LO16:
9919       reloc_status = Reloc_funcs::rello16(target, view, object, psymval,
9920                                           r_addend, extract_addend, address,
9921                                           gp_disp, r_type);
9922       break;
9923
9924     case elfcpp::R_MIPS_LITERAL:
9925     case elfcpp::R_MICROMIPS_LITERAL:
9926       // Because we don't merge literal sections, we can handle this
9927       // just like R_MIPS_GPREL16.  In the long run, we should merge
9928       // shared literals, and then we will need to additional work
9929       // here.
9930
9931       // Fall through.
9932
9933     case elfcpp::R_MIPS_GPREL16:
9934     case elfcpp::R_MIPS16_GPREL:
9935     case elfcpp::R_MICROMIPS_GPREL7_S2:
9936     case elfcpp::R_MICROMIPS_GPREL16:
9937       reloc_status = Reloc_funcs::relgprel(view, object, psymval,
9938                                            target->adjusted_gp_value(object),
9939                                            r_addend, extract_addend,
9940                                            gsym == NULL, r_type);
9941       break;
9942
9943     case elfcpp::R_MIPS_PC16:
9944       reloc_status = Reloc_funcs::relpc16(view, object, psymval, address,
9945                                           r_addend, extract_addend, r_type);
9946       break;
9947     case elfcpp::R_MICROMIPS_PC7_S1:
9948       reloc_status = Reloc_funcs::relmicromips_pc7_s1(view, object, psymval,
9949                                                       address, r_addend,
9950                                                       extract_addend, r_type);
9951       break;
9952     case elfcpp::R_MICROMIPS_PC10_S1:
9953       reloc_status = Reloc_funcs::relmicromips_pc10_s1(view, object, psymval,
9954                                                        address, r_addend,
9955                                                        extract_addend, r_type);
9956       break;
9957     case elfcpp::R_MICROMIPS_PC16_S1:
9958       reloc_status = Reloc_funcs::relmicromips_pc16_s1(view, object, psymval,
9959                                                        address, r_addend,
9960                                                        extract_addend, r_type);
9961       break;
9962     case elfcpp::R_MIPS_GPREL32:
9963       reloc_status = Reloc_funcs::relgprel32(view, object, psymval,
9964                                              target->adjusted_gp_value(object),
9965                                              r_addend, extract_addend, r_type);
9966       break;
9967     case elfcpp::R_MIPS_GOT_HI16:
9968     case elfcpp::R_MIPS_CALL_HI16:
9969     case elfcpp::R_MICROMIPS_GOT_HI16:
9970     case elfcpp::R_MICROMIPS_CALL_HI16:
9971       if (gsym != NULL)
9972         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
9973                                                        object);
9974       else
9975         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
9976                                                        object);
9977       gp_offset = target->got_section()->gp_offset(got_offset, object);
9978       reloc_status = Reloc_funcs::relgot_hi16(view, gp_offset, r_type);
9979       update_got_entry = changed_symbol_value;
9980       break;
9981
9982     case elfcpp::R_MIPS_GOT_LO16:
9983     case elfcpp::R_MIPS_CALL_LO16:
9984     case elfcpp::R_MICROMIPS_GOT_LO16:
9985     case elfcpp::R_MICROMIPS_CALL_LO16:
9986       if (gsym != NULL)
9987         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
9988                                                        object);
9989       else
9990         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
9991                                                        object);
9992       gp_offset = target->got_section()->gp_offset(got_offset, object);
9993       reloc_status = Reloc_funcs::relgot_lo16(view, gp_offset, r_type);
9994       update_got_entry = changed_symbol_value;
9995       break;
9996
9997     case elfcpp::R_MIPS_GOT_DISP:
9998     case elfcpp::R_MICROMIPS_GOT_DISP:
9999       if (gsym != NULL)
10000         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
10001                                                        object);
10002       else
10003         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_STANDARD,
10004                                                        object);
10005       gp_offset = target->got_section()->gp_offset(got_offset, object);
10006       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10007       break;
10008
10009     case elfcpp::R_MIPS_CALL16:
10010     case elfcpp::R_MIPS16_CALL16:
10011     case elfcpp::R_MICROMIPS_CALL16:
10012       gold_assert(gsym != NULL);
10013       got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_STANDARD,
10014                                                      object);
10015       gp_offset = target->got_section()->gp_offset(got_offset, object);
10016       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10017       // TODO(sasa): We should also initialize update_got_entry in other places
10018       // where relgot is called.
10019       update_got_entry = changed_symbol_value;
10020       break;
10021
10022     case elfcpp::R_MIPS_GOT16:
10023     case elfcpp::R_MIPS16_GOT16:
10024     case elfcpp::R_MICROMIPS_GOT16:
10025       if (gsym != NULL)
10026         {
10027           got_offset = target->got_section()->got_offset(gsym,
10028                                                          GOT_TYPE_STANDARD,
10029                                                          object);
10030           gp_offset = target->got_section()->gp_offset(got_offset, object);
10031           reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10032         }
10033       else
10034         reloc_status = Reloc_funcs::relgot16_local(view, object, psymval,
10035                                                    r_addend, extract_addend,
10036                                                    r_type);
10037       update_got_entry = changed_symbol_value;
10038       break;
10039
10040     case elfcpp::R_MIPS_TLS_GD:
10041     case elfcpp::R_MIPS16_TLS_GD:
10042     case elfcpp::R_MICROMIPS_TLS_GD:
10043       if (gsym != NULL)
10044         got_offset = target->got_section()->got_offset(gsym, GOT_TYPE_TLS_PAIR,
10045                                                        object);
10046       else
10047         got_offset = target->got_section()->got_offset(r_sym, GOT_TYPE_TLS_PAIR,
10048                                                        object);
10049       gp_offset = target->got_section()->gp_offset(got_offset, object);
10050       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10051       break;
10052
10053     case elfcpp::R_MIPS_TLS_GOTTPREL:
10054     case elfcpp::R_MIPS16_TLS_GOTTPREL:
10055     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
10056       if (gsym != NULL)
10057         got_offset = target->got_section()->got_offset(gsym,
10058                                                        GOT_TYPE_TLS_OFFSET,
10059                                                        object);
10060       else
10061         got_offset = target->got_section()->got_offset(r_sym,
10062                                                        GOT_TYPE_TLS_OFFSET,
10063                                                        object);
10064       gp_offset = target->got_section()->gp_offset(got_offset, object);
10065       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10066       break;
10067
10068     case elfcpp::R_MIPS_TLS_LDM:
10069     case elfcpp::R_MIPS16_TLS_LDM:
10070     case elfcpp::R_MICROMIPS_TLS_LDM:
10071       // Relocate the field with the offset of the GOT entry for
10072       // the module index.
10073       got_offset = target->got_section()->tls_ldm_offset(object);
10074       gp_offset = target->got_section()->gp_offset(got_offset, object);
10075       reloc_status = Reloc_funcs::relgot(view, gp_offset, r_type);
10076       break;
10077
10078     case elfcpp::R_MIPS_GOT_PAGE:
10079     case elfcpp::R_MICROMIPS_GOT_PAGE:
10080       reloc_status = Reloc_funcs::relgotpage(target, view, object, psymval,
10081                                              r_addend, extract_addend, r_type);
10082       break;
10083
10084     case elfcpp::R_MIPS_GOT_OFST:
10085     case elfcpp::R_MICROMIPS_GOT_OFST:
10086       reloc_status = Reloc_funcs::relgotofst(target, view, object, psymval,
10087                                              r_addend, extract_addend, local,
10088                                              r_type);
10089       break;
10090
10091     case elfcpp::R_MIPS_JALR:
10092     case elfcpp::R_MICROMIPS_JALR:
10093       // This relocation is only a hint.  In some cases, we optimize
10094       // it into a bal instruction.  But we don't try to optimize
10095       // when the symbol does not resolve locally.
10096       if (gsym == NULL || symbol_calls_local(gsym, gsym->has_dynsym_index()))
10097         reloc_status = Reloc_funcs::reljalr(view, object, psymval, address,
10098                                             r_addend, extract_addend,
10099                                             cross_mode_jump, r_type,
10100                                             target->jalr_to_bal(),
10101                                             target->jr_to_b());
10102       break;
10103
10104     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
10105     case elfcpp::R_MIPS16_TLS_DTPREL_HI16:
10106     case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16:
10107       reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval,
10108                                              elfcpp::DTP_OFFSET, r_addend,
10109                                              extract_addend, r_type);
10110       break;
10111     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
10112     case elfcpp::R_MIPS16_TLS_DTPREL_LO16:
10113     case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16:
10114       reloc_status = Reloc_funcs::tlsrello16(view, object, psymval,
10115                                              elfcpp::DTP_OFFSET, r_addend,
10116                                              extract_addend, r_type);
10117       break;
10118     case elfcpp::R_MIPS_TLS_DTPREL32:
10119     case elfcpp::R_MIPS_TLS_DTPREL64:
10120       reloc_status = Reloc_funcs::tlsrel32(view, object, psymval,
10121                                            elfcpp::DTP_OFFSET, r_addend,
10122                                            extract_addend, r_type);
10123       break;
10124     case elfcpp::R_MIPS_TLS_TPREL_HI16:
10125     case elfcpp::R_MIPS16_TLS_TPREL_HI16:
10126     case elfcpp::R_MICROMIPS_TLS_TPREL_HI16:
10127       reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval,
10128                                              elfcpp::TP_OFFSET, r_addend,
10129                                              extract_addend, r_type);
10130       break;
10131     case elfcpp::R_MIPS_TLS_TPREL_LO16:
10132     case elfcpp::R_MIPS16_TLS_TPREL_LO16:
10133     case elfcpp::R_MICROMIPS_TLS_TPREL_LO16:
10134       reloc_status = Reloc_funcs::tlsrello16(view, object, psymval,
10135                                              elfcpp::TP_OFFSET, r_addend,
10136                                              extract_addend, r_type);
10137       break;
10138     case elfcpp::R_MIPS_TLS_TPREL32:
10139     case elfcpp::R_MIPS_TLS_TPREL64:
10140       reloc_status = Reloc_funcs::tlsrel32(view, object, psymval,
10141                                            elfcpp::TP_OFFSET, r_addend,
10142                                            extract_addend, r_type);
10143       break;
10144     case elfcpp::R_MIPS_SUB:
10145     case elfcpp::R_MICROMIPS_SUB:
10146       reloc_status = Reloc_funcs::relsub(view, object, psymval, r_addend,
10147                                          extract_addend, r_type);
10148       break;
10149     default:
10150       gold_error_at_location(relinfo, relnum, r_offset,
10151                              _("unsupported reloc %u"), r_type);
10152       break;
10153     }
10154
10155   if (update_got_entry)
10156     {
10157       Mips_output_data_got<size, big_endian>* got = target->got_section();
10158       if (mips_sym != NULL && mips_sym->get_applied_secondary_got_fixup())
10159         got->update_got_entry(got->get_primary_got_offset(mips_sym),
10160                               psymval->value(object, 0));
10161       else
10162         got->update_got_entry(got_offset, psymval->value(object, 0));
10163     }
10164
10165   // Report any errors.
10166   switch (reloc_status)
10167     {
10168     case Reloc_funcs::STATUS_OKAY:
10169       break;
10170     case Reloc_funcs::STATUS_OVERFLOW:
10171       gold_error_at_location(relinfo, relnum, r_offset,
10172                              _("relocation overflow"));
10173       break;
10174     case Reloc_funcs::STATUS_BAD_RELOC:
10175       gold_error_at_location(relinfo, relnum, r_offset,
10176         _("unexpected opcode while processing relocation"));
10177       break;
10178     default:
10179       gold_unreachable();
10180     }
10181
10182   return true;
10183 }
10184
10185 template<int size, bool big_endian>
10186 inline bool
10187 Target_mips<size, big_endian>::Relocate::relocate(
10188                         const Relocate_info<size, big_endian>* relinfo,
10189                         Target_mips* target,
10190                         Output_section* output_section,
10191                         size_t relnum,
10192                         const elfcpp::Rela<size, big_endian>& reloc,
10193                         unsigned int r_type,
10194                         const Sized_symbol<size>* gsym,
10195                         const Symbol_value<size>* psymval,
10196                         unsigned char* view,
10197                         Mips_address address,
10198                         section_size_type view_size)
10199 {
10200   return relocate(
10201     relinfo,
10202     target,
10203     output_section,
10204     relnum,
10205     &reloc,
10206     (const elfcpp::Rel<size, big_endian>*) NULL,
10207     elfcpp::SHT_RELA,
10208     r_type,
10209     gsym,
10210     psymval,
10211     view,
10212     address,
10213     view_size);
10214 }
10215
10216 template<int size, bool big_endian>
10217 inline bool
10218 Target_mips<size, big_endian>::Relocate::relocate(
10219                         const Relocate_info<size, big_endian>* relinfo,
10220                         Target_mips* target,
10221                         Output_section* output_section,
10222                         size_t relnum,
10223                         const elfcpp::Rel<size, big_endian>& reloc,
10224                         unsigned int r_type,
10225                         const Sized_symbol<size>* gsym,
10226                         const Symbol_value<size>* psymval,
10227                         unsigned char* view,
10228                         Mips_address address,
10229                         section_size_type view_size)
10230 {
10231   return relocate(
10232     relinfo,
10233     target,
10234     output_section,
10235     relnum,
10236     (const elfcpp::Rela<size, big_endian>*) NULL,
10237     &reloc,
10238     elfcpp::SHT_REL,
10239     r_type,
10240     gsym,
10241     psymval,
10242     view,
10243     address,
10244     view_size);
10245 }
10246
10247 // Get the Reference_flags for a particular relocation.
10248
10249 template<int size, bool big_endian>
10250 int
10251 Target_mips<size, big_endian>::Scan::get_reference_flags(
10252                        unsigned int r_type)
10253 {
10254   switch (r_type)
10255     {
10256     case elfcpp::R_MIPS_NONE:
10257       // No symbol reference.
10258       return 0;
10259
10260     case elfcpp::R_MIPS_16:
10261     case elfcpp::R_MIPS_32:
10262     case elfcpp::R_MIPS_64:
10263     case elfcpp::R_MIPS_HI16:
10264     case elfcpp::R_MIPS_LO16:
10265     case elfcpp::R_MIPS16_HI16:
10266     case elfcpp::R_MIPS16_LO16:
10267     case elfcpp::R_MICROMIPS_HI16:
10268     case elfcpp::R_MICROMIPS_LO16:
10269       return Symbol::ABSOLUTE_REF;
10270
10271     case elfcpp::R_MIPS_26:
10272     case elfcpp::R_MIPS16_26:
10273     case elfcpp::R_MICROMIPS_26_S1:
10274       return Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF;
10275
10276     case elfcpp::R_MIPS_GPREL32:
10277     case elfcpp::R_MIPS_GPREL16:
10278     case elfcpp::R_MIPS_REL32:
10279     case elfcpp::R_MIPS16_GPREL:
10280       return Symbol::RELATIVE_REF;
10281
10282     case elfcpp::R_MIPS_PC16:
10283     case elfcpp::R_MIPS_PC32:
10284     case elfcpp::R_MIPS_JALR:
10285     case elfcpp::R_MICROMIPS_JALR:
10286       return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
10287
10288     case elfcpp::R_MIPS_GOT16:
10289     case elfcpp::R_MIPS_CALL16:
10290     case elfcpp::R_MIPS_GOT_DISP:
10291     case elfcpp::R_MIPS_GOT_HI16:
10292     case elfcpp::R_MIPS_GOT_LO16:
10293     case elfcpp::R_MIPS_CALL_HI16:
10294     case elfcpp::R_MIPS_CALL_LO16:
10295     case elfcpp::R_MIPS_LITERAL:
10296     case elfcpp::R_MIPS_GOT_PAGE:
10297     case elfcpp::R_MIPS_GOT_OFST:
10298     case elfcpp::R_MIPS16_GOT16:
10299     case elfcpp::R_MIPS16_CALL16:
10300     case elfcpp::R_MICROMIPS_GOT16:
10301     case elfcpp::R_MICROMIPS_CALL16:
10302     case elfcpp::R_MICROMIPS_GOT_HI16:
10303     case elfcpp::R_MICROMIPS_GOT_LO16:
10304     case elfcpp::R_MICROMIPS_CALL_HI16:
10305     case elfcpp::R_MICROMIPS_CALL_LO16:
10306       // Absolute in GOT.
10307       return Symbol::RELATIVE_REF;
10308
10309     case elfcpp::R_MIPS_TLS_DTPMOD32:
10310     case elfcpp::R_MIPS_TLS_DTPREL32:
10311     case elfcpp::R_MIPS_TLS_DTPMOD64:
10312     case elfcpp::R_MIPS_TLS_DTPREL64:
10313     case elfcpp::R_MIPS_TLS_GD:
10314     case elfcpp::R_MIPS_TLS_LDM:
10315     case elfcpp::R_MIPS_TLS_DTPREL_HI16:
10316     case elfcpp::R_MIPS_TLS_DTPREL_LO16:
10317     case elfcpp::R_MIPS_TLS_GOTTPREL:
10318     case elfcpp::R_MIPS_TLS_TPREL32:
10319     case elfcpp::R_MIPS_TLS_TPREL64:
10320     case elfcpp::R_MIPS_TLS_TPREL_HI16:
10321     case elfcpp::R_MIPS_TLS_TPREL_LO16:
10322     case elfcpp::R_MIPS16_TLS_GD:
10323     case elfcpp::R_MIPS16_TLS_GOTTPREL:
10324     case elfcpp::R_MICROMIPS_TLS_GD:
10325     case elfcpp::R_MICROMIPS_TLS_GOTTPREL:
10326     case elfcpp::R_MICROMIPS_TLS_TPREL_HI16:
10327     case elfcpp::R_MICROMIPS_TLS_TPREL_LO16:
10328       return Symbol::TLS_REF;
10329
10330     case elfcpp::R_MIPS_COPY:
10331     case elfcpp::R_MIPS_JUMP_SLOT:
10332     default:
10333       gold_unreachable();
10334       // Not expected.  We will give an error later.
10335       return 0;
10336     }
10337 }
10338
10339 // Report an unsupported relocation against a local symbol.
10340
10341 template<int size, bool big_endian>
10342 void
10343 Target_mips<size, big_endian>::Scan::unsupported_reloc_local(
10344                         Sized_relobj_file<size, big_endian>* object,
10345                         unsigned int r_type)
10346 {
10347   gold_error(_("%s: unsupported reloc %u against local symbol"),
10348              object->name().c_str(), r_type);
10349 }
10350
10351 // Report an unsupported relocation against a global symbol.
10352
10353 template<int size, bool big_endian>
10354 void
10355 Target_mips<size, big_endian>::Scan::unsupported_reloc_global(
10356                         Sized_relobj_file<size, big_endian>* object,
10357                         unsigned int r_type,
10358                         Symbol* gsym)
10359 {
10360   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
10361              object->name().c_str(), r_type, gsym->demangled_name().c_str());
10362 }
10363
10364 // Return printable name for ABI.
10365 template<int size, bool big_endian>
10366 const char*
10367 Target_mips<size, big_endian>::elf_mips_abi_name(elfcpp::Elf_Word e_flags,
10368                                                  unsigned char ei_class)
10369 {
10370   switch (e_flags & elfcpp::EF_MIPS_ABI)
10371     {
10372     case 0:
10373       if ((e_flags & elfcpp::EF_MIPS_ABI2) != 0)
10374         return "N32";
10375       else if (elfcpp::abi_64(ei_class))
10376         return "64";
10377       else
10378         return "none";
10379     case elfcpp::E_MIPS_ABI_O32:
10380       return "O32";
10381     case elfcpp::E_MIPS_ABI_O64:
10382       return "O64";
10383     case elfcpp::E_MIPS_ABI_EABI32:
10384       return "EABI32";
10385     case elfcpp::E_MIPS_ABI_EABI64:
10386       return "EABI64";
10387     default:
10388       return "unknown abi";
10389     }
10390 }
10391
10392 template<int size, bool big_endian>
10393 const char*
10394 Target_mips<size, big_endian>::elf_mips_mach_name(elfcpp::Elf_Word e_flags)
10395 {
10396   switch (e_flags & elfcpp::EF_MIPS_MACH)
10397     {
10398     case elfcpp::E_MIPS_MACH_3900:
10399       return "mips:3900";
10400     case elfcpp::E_MIPS_MACH_4010:
10401       return "mips:4010";
10402     case elfcpp::E_MIPS_MACH_4100:
10403       return "mips:4100";
10404     case elfcpp::E_MIPS_MACH_4111:
10405       return "mips:4111";
10406     case elfcpp::E_MIPS_MACH_4120:
10407       return "mips:4120";
10408     case elfcpp::E_MIPS_MACH_4650:
10409       return "mips:4650";
10410     case elfcpp::E_MIPS_MACH_5400:
10411       return "mips:5400";
10412     case elfcpp::E_MIPS_MACH_5500:
10413       return "mips:5500";
10414     case elfcpp::E_MIPS_MACH_SB1:
10415       return "mips:sb1";
10416     case elfcpp::E_MIPS_MACH_9000:
10417       return "mips:9000";
10418     case elfcpp::E_MIPS_MACH_LS2E:
10419       return "mips:loongson-2e";
10420     case elfcpp::E_MIPS_MACH_LS2F:
10421       return "mips:loongson-2f";
10422     case elfcpp::E_MIPS_MACH_LS3A:
10423       return "mips:loongson-3a";
10424     case elfcpp::E_MIPS_MACH_OCTEON:
10425       return "mips:octeon";
10426     case elfcpp::E_MIPS_MACH_OCTEON2:
10427       return "mips:octeon2";
10428     case elfcpp::E_MIPS_MACH_XLR:
10429       return "mips:xlr";
10430     default:
10431       switch (e_flags & elfcpp::EF_MIPS_ARCH)
10432         {
10433         default:
10434         case elfcpp::E_MIPS_ARCH_1:
10435           return "mips:3000";
10436
10437         case elfcpp::E_MIPS_ARCH_2:
10438           return "mips:6000";
10439
10440         case elfcpp::E_MIPS_ARCH_3:
10441           return "mips:4000";
10442
10443         case elfcpp::E_MIPS_ARCH_4:
10444           return "mips:8000";
10445
10446         case elfcpp::E_MIPS_ARCH_5:
10447           return "mips:mips5";
10448
10449         case elfcpp::E_MIPS_ARCH_32:
10450           return "mips:isa32";
10451
10452         case elfcpp::E_MIPS_ARCH_64:
10453           return "mips:isa64";
10454
10455         case elfcpp::E_MIPS_ARCH_32R2:
10456           return "mips:isa32r2";
10457
10458         case elfcpp::E_MIPS_ARCH_64R2:
10459           return "mips:isa64r2";
10460         }
10461     }
10462     return "unknown CPU";
10463 }
10464
10465 template<int size, bool big_endian>
10466 const Target::Target_info Target_mips<size, big_endian>::mips_info =
10467 {
10468   size,                 // size
10469   big_endian,           // is_big_endian
10470   elfcpp::EM_MIPS,      // machine_code
10471   true,                 // has_make_symbol
10472   false,                // has_resolve
10473   false,                // has_code_fill
10474   true,                 // is_default_stack_executable
10475   false,                // can_icf_inline_merge_sections
10476   '\0',                 // wrap_char
10477   "/lib/ld.so.1",       // dynamic_linker
10478   0x400000,             // default_text_segment_address
10479   64 * 1024,            // abi_pagesize (overridable by -z max-page-size)
10480   4 * 1024,             // common_pagesize (overridable by -z common-page-size)
10481   false,                // isolate_execinstr
10482   0,                    // rosegment_gap
10483   elfcpp::SHN_UNDEF,    // small_common_shndx
10484   elfcpp::SHN_UNDEF,    // large_common_shndx
10485   0,                    // small_common_section_flags
10486   0,                    // large_common_section_flags
10487   NULL,                 // attributes_section
10488   NULL,                 // attributes_vendor
10489   "__start"             // entry_symbol_name
10490 };
10491
10492 template<int size, bool big_endian>
10493 class Target_mips_nacl : public Target_mips<size, big_endian>
10494 {
10495  public:
10496   Target_mips_nacl()
10497     : Target_mips<size, big_endian>(&mips_nacl_info)
10498   { }
10499
10500  private:
10501   static const Target::Target_info mips_nacl_info;
10502 };
10503
10504 template<int size, bool big_endian>
10505 const Target::Target_info Target_mips_nacl<size, big_endian>::mips_nacl_info =
10506 {
10507   size,                 // size
10508   big_endian,           // is_big_endian
10509   elfcpp::EM_MIPS,      // machine_code
10510   true,                 // has_make_symbol
10511   false,                // has_resolve
10512   false,                // has_code_fill
10513   true,                 // is_default_stack_executable
10514   false,                // can_icf_inline_merge_sections
10515   '\0',                 // wrap_char
10516   "/lib/ld.so.1",       // dynamic_linker
10517   0x20000,              // default_text_segment_address
10518   0x10000,              // abi_pagesize (overridable by -z max-page-size)
10519   0x10000,              // common_pagesize (overridable by -z common-page-size)
10520   true,                 // isolate_execinstr
10521   0x10000000,           // rosegment_gap
10522   elfcpp::SHN_UNDEF,    // small_common_shndx
10523   elfcpp::SHN_UNDEF,    // large_common_shndx
10524   0,                    // small_common_section_flags
10525   0,                    // large_common_section_flags
10526   NULL,                 // attributes_section
10527   NULL,                 // attributes_vendor
10528   "_start"              // entry_symbol_name
10529 };
10530
10531 // Target selector for Mips.  Note this is never instantiated directly.
10532 // It's only used in Target_selector_mips_nacl, below.
10533
10534 template<int size, bool big_endian>
10535 class Target_selector_mips : public Target_selector
10536 {
10537 public:
10538   Target_selector_mips()
10539     : Target_selector(elfcpp::EM_MIPS, size, big_endian,
10540                 (size == 64 ?
10541                   (big_endian ? "elf64-tradbigmips" : "elf64-tradlittlemips") :
10542                   (big_endian ? "elf32-tradbigmips" : "elf32-tradlittlemips")),
10543                 (size == 64 ?
10544                   (big_endian ? "elf64-tradbigmips" : "elf64-tradlittlemips") :
10545                   (big_endian ? "elf32-tradbigmips" : "elf32-tradlittlemips")))
10546   { }
10547
10548   Target* do_instantiate_target()
10549   { return new Target_mips<size, big_endian>(); }
10550 };
10551
10552 template<int size, bool big_endian>
10553 class Target_selector_mips_nacl
10554   : public Target_selector_nacl<Target_selector_mips<size, big_endian>,
10555                                 Target_mips_nacl<size, big_endian> >
10556 {
10557  public:
10558   Target_selector_mips_nacl()
10559     : Target_selector_nacl<Target_selector_mips<size, big_endian>,
10560                            Target_mips_nacl<size, big_endian> >(
10561         // NaCl currently supports only MIPS32 little-endian.
10562         "mipsel", "elf32-tradlittlemips-nacl", "elf32-tradlittlemips-nacl")
10563   { }
10564 };
10565
10566 Target_selector_mips_nacl<32, true> target_selector_mips32;
10567 Target_selector_mips_nacl<32, false> target_selector_mips32el;
10568 Target_selector_mips_nacl<64, true> target_selector_mips64;
10569 Target_selector_mips_nacl<64, false> target_selector_mips64el;
10570
10571 } // End anonymous namespace.