Move potentially obsolete BFD targets into the definitely obsolete section. Add...
[external/binutils.git] / bfd / elfxx-mips.c
1 /* MIPS-specific support for ELF
2    Copyright (C) 1993-2019 Free Software Foundation, Inc.
3
4    Most of the information added by Ian Lance Taylor, Cygnus Support,
5    <ian@cygnus.com>.
6    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
7    <mark@codesourcery.com>
8    Traditional MIPS targets support added by Koundinya.K, Dansk Data
9    Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
10
11    This file is part of BFD, the Binary File Descriptor library.
12
13    This program is free software; you can redistribute it and/or modify
14    it under the terms of the GNU General Public License as published by
15    the Free Software Foundation; either version 3 of the License, or
16    (at your option) any later version.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
26    MA 02110-1301, USA.  */
27
28
29 /* This file handles functionality common to the different MIPS ABI's.  */
30
31 #include "sysdep.h"
32 #include "bfd.h"
33 #include "libbfd.h"
34 #include "libiberty.h"
35 #include "elf-bfd.h"
36 #include "elfxx-mips.h"
37 #include "elf/mips.h"
38 #include "elf-vxworks.h"
39 #include "dwarf2.h"
40
41 /* Get the ECOFF swapping routines.  */
42 #include "coff/sym.h"
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
46
47 #include "hashtab.h"
48
49 /* Types of TLS GOT entry.  */
50 enum mips_got_tls_type {
51   GOT_TLS_NONE,
52   GOT_TLS_GD,
53   GOT_TLS_LDM,
54   GOT_TLS_IE
55 };
56
57 /* This structure is used to hold information about one GOT entry.
58    There are four types of entry:
59
60       (1) an absolute address
61             requires: abfd == NULL
62             fields: d.address
63
64       (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd
65             requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM
66             fields: abfd, symndx, d.addend, tls_type
67
68       (3) a SYMBOL address, where SYMBOL is not local to an input bfd
69             requires: abfd != NULL, symndx == -1
70             fields: d.h, tls_type
71
72       (4) a TLS LDM slot
73             requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM
74             fields: none; there's only one of these per GOT.  */
75 struct mips_got_entry
76 {
77   /* One input bfd that needs the GOT entry.  */
78   bfd *abfd;
79   /* The index of the symbol, as stored in the relocation r_info, if
80      we have a local symbol; -1 otherwise.  */
81   long symndx;
82   union
83   {
84     /* If abfd == NULL, an address that must be stored in the got.  */
85     bfd_vma address;
86     /* If abfd != NULL && symndx != -1, the addend of the relocation
87        that should be added to the symbol value.  */
88     bfd_vma addend;
89     /* If abfd != NULL && symndx == -1, the hash table entry
90        corresponding to a symbol in the GOT.  The symbol's entry
91        is in the local area if h->global_got_area is GGA_NONE,
92        otherwise it is in the global area.  */
93     struct mips_elf_link_hash_entry *h;
94   } d;
95
96   /* The TLS type of this GOT entry.  An LDM GOT entry will be a local
97      symbol entry with r_symndx == 0.  */
98   unsigned char tls_type;
99
100   /* True if we have filled in the GOT contents for a TLS entry,
101      and created the associated relocations.  */
102   unsigned char tls_initialized;
103
104   /* The offset from the beginning of the .got section to the entry
105      corresponding to this symbol+addend.  If it's a global symbol
106      whose offset is yet to be decided, it's going to be -1.  */
107   long gotidx;
108 };
109
110 /* This structure represents a GOT page reference from an input bfd.
111    Each instance represents a symbol + ADDEND, where the representation
112    of the symbol depends on whether it is local to the input bfd.
113    If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD.
114    Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry.
115
116    Page references with SYMNDX >= 0 always become page references
117    in the output.  Page references with SYMNDX < 0 only become page
118    references if the symbol binds locally; in other cases, the page
119    reference decays to a global GOT reference.  */
120 struct mips_got_page_ref
121 {
122   long symndx;
123   union
124   {
125     struct mips_elf_link_hash_entry *h;
126     bfd *abfd;
127   } u;
128   bfd_vma addend;
129 };
130
131 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
132    The structures form a non-overlapping list that is sorted by increasing
133    MIN_ADDEND.  */
134 struct mips_got_page_range
135 {
136   struct mips_got_page_range *next;
137   bfd_signed_vma min_addend;
138   bfd_signed_vma max_addend;
139 };
140
141 /* This structure describes the range of addends that are applied to page
142    relocations against a given section.  */
143 struct mips_got_page_entry
144 {
145   /* The section that these entries are based on.  */
146   asection *sec;
147   /* The ranges for this page entry.  */
148   struct mips_got_page_range *ranges;
149   /* The maximum number of page entries needed for RANGES.  */
150   bfd_vma num_pages;
151 };
152
153 /* This structure is used to hold .got information when linking.  */
154
155 struct mips_got_info
156 {
157   /* The number of global .got entries.  */
158   unsigned int global_gotno;
159   /* The number of global .got entries that are in the GGA_RELOC_ONLY area.  */
160   unsigned int reloc_only_gotno;
161   /* The number of .got slots used for TLS.  */
162   unsigned int tls_gotno;
163   /* The first unused TLS .got entry.  Used only during
164      mips_elf_initialize_tls_index.  */
165   unsigned int tls_assigned_gotno;
166   /* The number of local .got entries, eventually including page entries.  */
167   unsigned int local_gotno;
168   /* The maximum number of page entries needed.  */
169   unsigned int page_gotno;
170   /* The number of relocations needed for the GOT entries.  */
171   unsigned int relocs;
172   /* The first unused local .got entry.  */
173   unsigned int assigned_low_gotno;
174   /* The last unused local .got entry.  */
175   unsigned int assigned_high_gotno;
176   /* A hash table holding members of the got.  */
177   struct htab *got_entries;
178   /* A hash table holding mips_got_page_ref structures.  */
179   struct htab *got_page_refs;
180   /* A hash table of mips_got_page_entry structures.  */
181   struct htab *got_page_entries;
182   /* In multi-got links, a pointer to the next got (err, rather, most
183      of the time, it points to the previous got).  */
184   struct mips_got_info *next;
185 };
186
187 /* Structure passed when merging bfds' gots.  */
188
189 struct mips_elf_got_per_bfd_arg
190 {
191   /* The output bfd.  */
192   bfd *obfd;
193   /* The link information.  */
194   struct bfd_link_info *info;
195   /* A pointer to the primary got, i.e., the one that's going to get
196      the implicit relocations from DT_MIPS_LOCAL_GOTNO and
197      DT_MIPS_GOTSYM.  */
198   struct mips_got_info *primary;
199   /* A non-primary got we're trying to merge with other input bfd's
200      gots.  */
201   struct mips_got_info *current;
202   /* The maximum number of got entries that can be addressed with a
203      16-bit offset.  */
204   unsigned int max_count;
205   /* The maximum number of page entries needed by each got.  */
206   unsigned int max_pages;
207   /* The total number of global entries which will live in the
208      primary got and be automatically relocated.  This includes
209      those not referenced by the primary GOT but included in
210      the "master" GOT.  */
211   unsigned int global_count;
212 };
213
214 /* A structure used to pass information to htab_traverse callbacks
215    when laying out the GOT.  */
216
217 struct mips_elf_traverse_got_arg
218 {
219   struct bfd_link_info *info;
220   struct mips_got_info *g;
221   int value;
222 };
223
224 struct _mips_elf_section_data
225 {
226   struct bfd_elf_section_data elf;
227   union
228   {
229     bfd_byte *tdata;
230   } u;
231 };
232
233 #define mips_elf_section_data(sec) \
234   ((struct _mips_elf_section_data *) elf_section_data (sec))
235
236 #define is_mips_elf(bfd)                                \
237   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
238    && elf_tdata (bfd) != NULL                           \
239    && elf_object_id (bfd) == MIPS_ELF_DATA)
240
241 /* The ABI says that every symbol used by dynamic relocations must have
242    a global GOT entry.  Among other things, this provides the dynamic
243    linker with a free, directly-indexed cache.  The GOT can therefore
244    contain symbols that are not referenced by GOT relocations themselves
245    (in other words, it may have symbols that are not referenced by things
246    like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
247
248    GOT relocations are less likely to overflow if we put the associated
249    GOT entries towards the beginning.  We therefore divide the global
250    GOT entries into two areas: "normal" and "reloc-only".  Entries in
251    the first area can be used for both dynamic relocations and GP-relative
252    accesses, while those in the "reloc-only" area are for dynamic
253    relocations only.
254
255    These GGA_* ("Global GOT Area") values are organised so that lower
256    values are more general than higher values.  Also, non-GGA_NONE
257    values are ordered by the position of the area in the GOT.  */
258 #define GGA_NORMAL 0
259 #define GGA_RELOC_ONLY 1
260 #define GGA_NONE 2
261
262 /* Information about a non-PIC interface to a PIC function.  There are
263    two ways of creating these interfaces.  The first is to add:
264
265         lui     $25,%hi(func)
266         addiu   $25,$25,%lo(func)
267
268    immediately before a PIC function "func".  The second is to add:
269
270         lui     $25,%hi(func)
271         j       func
272         addiu   $25,$25,%lo(func)
273
274    to a separate trampoline section.
275
276    Stubs of the first kind go in a new section immediately before the
277    target function.  Stubs of the second kind go in a single section
278    pointed to by the hash table's "strampoline" field.  */
279 struct mips_elf_la25_stub {
280   /* The generated section that contains this stub.  */
281   asection *stub_section;
282
283   /* The offset of the stub from the start of STUB_SECTION.  */
284   bfd_vma offset;
285
286   /* One symbol for the original function.  Its location is available
287      in H->root.root.u.def.  */
288   struct mips_elf_link_hash_entry *h;
289 };
290
291 /* Macros for populating a mips_elf_la25_stub.  */
292
293 #define LA25_LUI(VAL) (0x3c190000 | (VAL))      /* lui t9,VAL */
294 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
295 #define LA25_ADDIU(VAL) (0x27390000 | (VAL))    /* addiu t9,t9,VAL */
296 #define LA25_LUI_MICROMIPS(VAL)                                         \
297   (0x41b90000 | (VAL))                          /* lui t9,VAL */
298 #define LA25_J_MICROMIPS(VAL)                                           \
299   (0xd4000000 | (((VAL) >> 1) & 0x3ffffff))     /* j VAL */
300 #define LA25_ADDIU_MICROMIPS(VAL)                                       \
301   (0x33390000 | (VAL))                          /* addiu t9,t9,VAL */
302
303 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
304    the dynamic symbols.  */
305
306 struct mips_elf_hash_sort_data
307 {
308   /* The symbol in the global GOT with the lowest dynamic symbol table
309      index.  */
310   struct elf_link_hash_entry *low;
311   /* The least dynamic symbol table index corresponding to a non-TLS
312      symbol with a GOT entry.  */
313   bfd_size_type min_got_dynindx;
314   /* The greatest dynamic symbol table index corresponding to a symbol
315      with a GOT entry that is not referenced (e.g., a dynamic symbol
316      with dynamic relocations pointing to it from non-primary GOTs).  */
317   bfd_size_type max_unref_got_dynindx;
318   /* The greatest dynamic symbol table index corresponding to a local
319      symbol.  */
320   bfd_size_type max_local_dynindx;
321   /* The greatest dynamic symbol table index corresponding to an external
322      symbol without a GOT entry.  */
323   bfd_size_type max_non_got_dynindx;
324 };
325
326 /* We make up to two PLT entries if needed, one for standard MIPS code
327    and one for compressed code, either a MIPS16 or microMIPS one.  We
328    keep a separate record of traditional lazy-binding stubs, for easier
329    processing.  */
330
331 struct plt_entry
332 {
333   /* Traditional SVR4 stub offset, or -1 if none.  */
334   bfd_vma stub_offset;
335
336   /* Standard PLT entry offset, or -1 if none.  */
337   bfd_vma mips_offset;
338
339   /* Compressed PLT entry offset, or -1 if none.  */
340   bfd_vma comp_offset;
341
342   /* The corresponding .got.plt index, or -1 if none.  */
343   bfd_vma gotplt_index;
344
345   /* Whether we need a standard PLT entry.  */
346   unsigned int need_mips : 1;
347
348   /* Whether we need a compressed PLT entry.  */
349   unsigned int need_comp : 1;
350 };
351
352 /* The MIPS ELF linker needs additional information for each symbol in
353    the global hash table.  */
354
355 struct mips_elf_link_hash_entry
356 {
357   struct elf_link_hash_entry root;
358
359   /* External symbol information.  */
360   EXTR esym;
361
362   /* The la25 stub we have created for ths symbol, if any.  */
363   struct mips_elf_la25_stub *la25_stub;
364
365   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
366      this symbol.  */
367   unsigned int possibly_dynamic_relocs;
368
369   /* If there is a stub that 32 bit functions should use to call this
370      16 bit function, this points to the section containing the stub.  */
371   asection *fn_stub;
372
373   /* If there is a stub that 16 bit functions should use to call this
374      32 bit function, this points to the section containing the stub.  */
375   asection *call_stub;
376
377   /* This is like the call_stub field, but it is used if the function
378      being called returns a floating point value.  */
379   asection *call_fp_stub;
380
381   /* The highest GGA_* value that satisfies all references to this symbol.  */
382   unsigned int global_got_area : 2;
383
384   /* True if all GOT relocations against this symbol are for calls.  This is
385      a looser condition than no_fn_stub below, because there may be other
386      non-call non-GOT relocations against the symbol.  */
387   unsigned int got_only_for_calls : 1;
388
389   /* True if one of the relocations described by possibly_dynamic_relocs
390      is against a readonly section.  */
391   unsigned int readonly_reloc : 1;
392
393   /* True if there is a relocation against this symbol that must be
394      resolved by the static linker (in other words, if the relocation
395      cannot possibly be made dynamic).  */
396   unsigned int has_static_relocs : 1;
397
398   /* True if we must not create a .MIPS.stubs entry for this symbol.
399      This is set, for example, if there are relocations related to
400      taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
401      See "MIPS ABI Supplement, 3rd Edition", p. 4-20.  */
402   unsigned int no_fn_stub : 1;
403
404   /* Whether we need the fn_stub; this is true if this symbol appears
405      in any relocs other than a 16 bit call.  */
406   unsigned int need_fn_stub : 1;
407
408   /* True if this symbol is referenced by branch relocations from
409      any non-PIC input file.  This is used to determine whether an
410      la25 stub is required.  */
411   unsigned int has_nonpic_branches : 1;
412
413   /* Does this symbol need a traditional MIPS lazy-binding stub
414      (as opposed to a PLT entry)?  */
415   unsigned int needs_lazy_stub : 1;
416
417   /* Does this symbol resolve to a PLT entry?  */
418   unsigned int use_plt_entry : 1;
419 };
420
421 /* MIPS ELF linker hash table.  */
422
423 struct mips_elf_link_hash_table
424 {
425   struct elf_link_hash_table root;
426
427   /* The number of .rtproc entries.  */
428   bfd_size_type procedure_count;
429
430   /* The size of the .compact_rel section (if SGI_COMPAT).  */
431   bfd_size_type compact_rel_size;
432
433   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
434      is set to the address of __rld_obj_head as in IRIX5 and IRIX6.  */
435   bfd_boolean use_rld_obj_head;
436
437   /* The  __rld_map or __rld_obj_head symbol. */
438   struct elf_link_hash_entry *rld_symbol;
439
440   /* This is set if we see any mips16 stub sections.  */
441   bfd_boolean mips16_stubs_seen;
442
443   /* True if we can generate copy relocs and PLTs.  */
444   bfd_boolean use_plts_and_copy_relocs;
445
446   /* True if we can only use 32-bit microMIPS instructions.  */
447   bfd_boolean insn32;
448
449   /* True if we suppress checks for invalid branches between ISA modes.  */
450   bfd_boolean ignore_branch_isa;
451
452   /* True if we're generating code for VxWorks.  */
453   bfd_boolean is_vxworks;
454
455   /* True if we already reported the small-data section overflow.  */
456   bfd_boolean small_data_overflow_reported;
457
458   /* True if we use the special `__gnu_absolute_zero' symbol.  */
459   bfd_boolean use_absolute_zero;
460
461   /* True if we have been configured for a GNU target.  */
462   bfd_boolean gnu_target;
463
464   /* Shortcuts to some dynamic sections, or NULL if they are not
465      being used.  */
466   asection *srelplt2;
467   asection *sstubs;
468
469   /* The master GOT information.  */
470   struct mips_got_info *got_info;
471
472   /* The global symbol in the GOT with the lowest index in the dynamic
473      symbol table.  */
474   struct elf_link_hash_entry *global_gotsym;
475
476   /* The size of the PLT header in bytes.  */
477   bfd_vma plt_header_size;
478
479   /* The size of a standard PLT entry in bytes.  */
480   bfd_vma plt_mips_entry_size;
481
482   /* The size of a compressed PLT entry in bytes.  */
483   bfd_vma plt_comp_entry_size;
484
485   /* The offset of the next standard PLT entry to create.  */
486   bfd_vma plt_mips_offset;
487
488   /* The offset of the next compressed PLT entry to create.  */
489   bfd_vma plt_comp_offset;
490
491   /* The index of the next .got.plt entry to create.  */
492   bfd_vma plt_got_index;
493
494   /* The number of functions that need a lazy-binding stub.  */
495   bfd_vma lazy_stub_count;
496
497   /* The size of a function stub entry in bytes.  */
498   bfd_vma function_stub_size;
499
500   /* The number of reserved entries at the beginning of the GOT.  */
501   unsigned int reserved_gotno;
502
503   /* The section used for mips_elf_la25_stub trampolines.
504      See the comment above that structure for details.  */
505   asection *strampoline;
506
507   /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
508      pairs.  */
509   htab_t la25_stubs;
510
511   /* A function FN (NAME, IS, OS) that creates a new input section
512      called NAME and links it to output section OS.  If IS is nonnull,
513      the new section should go immediately before it, otherwise it
514      should go at the (current) beginning of OS.
515
516      The function returns the new section on success, otherwise it
517      returns null.  */
518   asection *(*add_stub_section) (const char *, asection *, asection *);
519
520   /* Small local sym cache.  */
521   struct sym_cache sym_cache;
522
523   /* Is the PLT header compressed?  */
524   unsigned int plt_header_is_comp : 1;
525 };
526
527 /* Get the MIPS ELF linker hash table from a link_info structure.  */
528
529 #define mips_elf_hash_table(p) \
530   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
531   == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
532
533 /* A structure used to communicate with htab_traverse callbacks.  */
534 struct mips_htab_traverse_info
535 {
536   /* The usual link-wide information.  */
537   struct bfd_link_info *info;
538   bfd *output_bfd;
539
540   /* Starts off FALSE and is set to TRUE if the link should be aborted.  */
541   bfd_boolean error;
542 };
543
544 /* MIPS ELF private object data.  */
545
546 struct mips_elf_obj_tdata
547 {
548   /* Generic ELF private object data.  */
549   struct elf_obj_tdata root;
550
551   /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output.  */
552   bfd *abi_fp_bfd;
553
554   /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output.  */
555   bfd *abi_msa_bfd;
556
557   /* The abiflags for this object.  */
558   Elf_Internal_ABIFlags_v0 abiflags;
559   bfd_boolean abiflags_valid;
560
561   /* The GOT requirements of input bfds.  */
562   struct mips_got_info *got;
563
564   /* Used by _bfd_mips_elf_find_nearest_line.  The structure could be
565      included directly in this one, but there's no point to wasting
566      the memory just for the infrequently called find_nearest_line.  */
567   struct mips_elf_find_line *find_line_info;
568
569   /* An array of stub sections indexed by symbol number.  */
570   asection **local_stubs;
571   asection **local_call_stubs;
572
573   /* The Irix 5 support uses two virtual sections, which represent
574      text/data symbols defined in dynamic objects.  */
575   asymbol *elf_data_symbol;
576   asymbol *elf_text_symbol;
577   asection *elf_data_section;
578   asection *elf_text_section;
579 };
580
581 /* Get MIPS ELF private object data from BFD's tdata.  */
582
583 #define mips_elf_tdata(bfd) \
584   ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
585
586 #define TLS_RELOC_P(r_type) \
587   (r_type == R_MIPS_TLS_DTPMOD32                \
588    || r_type == R_MIPS_TLS_DTPMOD64             \
589    || r_type == R_MIPS_TLS_DTPREL32             \
590    || r_type == R_MIPS_TLS_DTPREL64             \
591    || r_type == R_MIPS_TLS_GD                   \
592    || r_type == R_MIPS_TLS_LDM                  \
593    || r_type == R_MIPS_TLS_DTPREL_HI16          \
594    || r_type == R_MIPS_TLS_DTPREL_LO16          \
595    || r_type == R_MIPS_TLS_GOTTPREL             \
596    || r_type == R_MIPS_TLS_TPREL32              \
597    || r_type == R_MIPS_TLS_TPREL64              \
598    || r_type == R_MIPS_TLS_TPREL_HI16           \
599    || r_type == R_MIPS_TLS_TPREL_LO16           \
600    || r_type == R_MIPS16_TLS_GD                 \
601    || r_type == R_MIPS16_TLS_LDM                \
602    || r_type == R_MIPS16_TLS_DTPREL_HI16        \
603    || r_type == R_MIPS16_TLS_DTPREL_LO16        \
604    || r_type == R_MIPS16_TLS_GOTTPREL           \
605    || r_type == R_MIPS16_TLS_TPREL_HI16         \
606    || r_type == R_MIPS16_TLS_TPREL_LO16         \
607    || r_type == R_MICROMIPS_TLS_GD              \
608    || r_type == R_MICROMIPS_TLS_LDM             \
609    || r_type == R_MICROMIPS_TLS_DTPREL_HI16     \
610    || r_type == R_MICROMIPS_TLS_DTPREL_LO16     \
611    || r_type == R_MICROMIPS_TLS_GOTTPREL        \
612    || r_type == R_MICROMIPS_TLS_TPREL_HI16      \
613    || r_type == R_MICROMIPS_TLS_TPREL_LO16)
614
615 /* Structure used to pass information to mips_elf_output_extsym.  */
616
617 struct extsym_info
618 {
619   bfd *abfd;
620   struct bfd_link_info *info;
621   struct ecoff_debug_info *debug;
622   const struct ecoff_debug_swap *swap;
623   bfd_boolean failed;
624 };
625
626 /* The names of the runtime procedure table symbols used on IRIX5.  */
627
628 static const char * const mips_elf_dynsym_rtproc_names[] =
629 {
630   "_procedure_table",
631   "_procedure_string_table",
632   "_procedure_table_size",
633   NULL
634 };
635
636 /* These structures are used to generate the .compact_rel section on
637    IRIX5.  */
638
639 typedef struct
640 {
641   unsigned long id1;            /* Always one?  */
642   unsigned long num;            /* Number of compact relocation entries.  */
643   unsigned long id2;            /* Always two?  */
644   unsigned long offset;         /* The file offset of the first relocation.  */
645   unsigned long reserved0;      /* Zero?  */
646   unsigned long reserved1;      /* Zero?  */
647 } Elf32_compact_rel;
648
649 typedef struct
650 {
651   bfd_byte id1[4];
652   bfd_byte num[4];
653   bfd_byte id2[4];
654   bfd_byte offset[4];
655   bfd_byte reserved0[4];
656   bfd_byte reserved1[4];
657 } Elf32_External_compact_rel;
658
659 typedef struct
660 {
661   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
662   unsigned int rtype : 4;       /* Relocation types. See below.  */
663   unsigned int dist2to : 8;
664   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
665   unsigned long konst;          /* KONST field. See below.  */
666   unsigned long vaddr;          /* VADDR to be relocated.  */
667 } Elf32_crinfo;
668
669 typedef struct
670 {
671   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
672   unsigned int rtype : 4;       /* Relocation types. See below.  */
673   unsigned int dist2to : 8;
674   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
675   unsigned long konst;          /* KONST field. See below.  */
676 } Elf32_crinfo2;
677
678 typedef struct
679 {
680   bfd_byte info[4];
681   bfd_byte konst[4];
682   bfd_byte vaddr[4];
683 } Elf32_External_crinfo;
684
685 typedef struct
686 {
687   bfd_byte info[4];
688   bfd_byte konst[4];
689 } Elf32_External_crinfo2;
690
691 /* These are the constants used to swap the bitfields in a crinfo.  */
692
693 #define CRINFO_CTYPE (0x1)
694 #define CRINFO_CTYPE_SH (31)
695 #define CRINFO_RTYPE (0xf)
696 #define CRINFO_RTYPE_SH (27)
697 #define CRINFO_DIST2TO (0xff)
698 #define CRINFO_DIST2TO_SH (19)
699 #define CRINFO_RELVADDR (0x7ffff)
700 #define CRINFO_RELVADDR_SH (0)
701
702 /* A compact relocation info has long (3 words) or short (2 words)
703    formats.  A short format doesn't have VADDR field and relvaddr
704    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
705 #define CRF_MIPS_LONG                   1
706 #define CRF_MIPS_SHORT                  0
707
708 /* There are 4 types of compact relocation at least. The value KONST
709    has different meaning for each type:
710
711    (type)               (konst)
712    CT_MIPS_REL32        Address in data
713    CT_MIPS_WORD         Address in word (XXX)
714    CT_MIPS_GPHI_LO      GP - vaddr
715    CT_MIPS_JMPAD        Address to jump
716    */
717
718 #define CRT_MIPS_REL32                  0xa
719 #define CRT_MIPS_WORD                   0xb
720 #define CRT_MIPS_GPHI_LO                0xc
721 #define CRT_MIPS_JMPAD                  0xd
722
723 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
724 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
725 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
726 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
727 \f
728 /* The structure of the runtime procedure descriptor created by the
729    loader for use by the static exception system.  */
730
731 typedef struct runtime_pdr {
732         bfd_vma adr;            /* Memory address of start of procedure.  */
733         long    regmask;        /* Save register mask.  */
734         long    regoffset;      /* Save register offset.  */
735         long    fregmask;       /* Save floating point register mask.  */
736         long    fregoffset;     /* Save floating point register offset.  */
737         long    frameoffset;    /* Frame size.  */
738         short   framereg;       /* Frame pointer register.  */
739         short   pcreg;          /* Offset or reg of return pc.  */
740         long    irpss;          /* Index into the runtime string table.  */
741         long    reserved;
742         struct exception_info *exception_info;/* Pointer to exception array.  */
743 } RPDR, *pRPDR;
744 #define cbRPDR sizeof (RPDR)
745 #define rpdNil ((pRPDR) 0)
746 \f
747 static struct mips_got_entry *mips_elf_create_local_got_entry
748   (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
749    struct mips_elf_link_hash_entry *, int);
750 static bfd_boolean mips_elf_sort_hash_table_f
751   (struct mips_elf_link_hash_entry *, void *);
752 static bfd_vma mips_elf_high
753   (bfd_vma);
754 static bfd_boolean mips_elf_create_dynamic_relocation
755   (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
756    struct mips_elf_link_hash_entry *, asection *, bfd_vma,
757    bfd_vma *, asection *);
758 static bfd_vma mips_elf_adjust_gp
759   (bfd *, struct mips_got_info *, bfd *);
760
761 /* This will be used when we sort the dynamic relocation records.  */
762 static bfd *reldyn_sorting_bfd;
763
764 /* True if ABFD is for CPUs with load interlocking that include
765    non-MIPS1 CPUs and R3900.  */
766 #define LOAD_INTERLOCKS_P(abfd) \
767   (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
768    || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
769
770 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
771    This should be safe for all architectures.  We enable this predicate
772    for RM9000 for now.  */
773 #define JAL_TO_BAL_P(abfd) \
774   ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
775
776 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
777    This should be safe for all architectures.  We enable this predicate for
778    all CPUs.  */
779 #define JALR_TO_BAL_P(abfd) 1
780
781 /* True if ABFD is for CPUs that are faster if JR is converted to B.
782    This should be safe for all architectures.  We enable this predicate for
783    all CPUs.  */
784 #define JR_TO_B_P(abfd) 1
785
786 /* True if ABFD is a PIC object.  */
787 #define PIC_OBJECT_P(abfd) \
788   ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
789
790 /* Nonzero if ABFD is using the O32 ABI.  */
791 #define ABI_O32_P(abfd) \
792   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
793
794 /* Nonzero if ABFD is using the N32 ABI.  */
795 #define ABI_N32_P(abfd) \
796   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
797
798 /* Nonzero if ABFD is using the N64 ABI.  */
799 #define ABI_64_P(abfd) \
800   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
801
802 /* Nonzero if ABFD is using NewABI conventions.  */
803 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
804
805 /* Nonzero if ABFD has microMIPS code.  */
806 #define MICROMIPS_P(abfd) \
807   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
808
809 /* Nonzero if ABFD is MIPS R6.  */
810 #define MIPSR6_P(abfd) \
811   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
812     || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
813
814 /* The IRIX compatibility level we are striving for.  */
815 #define IRIX_COMPAT(abfd) \
816   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
817
818 /* Whether we are trying to be compatible with IRIX at all.  */
819 #define SGI_COMPAT(abfd) \
820   (IRIX_COMPAT (abfd) != ict_none)
821
822 /* The name of the options section.  */
823 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
824   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
825
826 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
827    Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
828 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
829   (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
830
831 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section.  */
832 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
833   (strcmp (NAME, ".MIPS.abiflags") == 0)
834
835 /* Whether the section is readonly.  */
836 #define MIPS_ELF_READONLY_SECTION(sec) \
837   ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \
838    == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
839
840 /* The name of the stub section.  */
841 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
842
843 /* The size of an external REL relocation.  */
844 #define MIPS_ELF_REL_SIZE(abfd) \
845   (get_elf_backend_data (abfd)->s->sizeof_rel)
846
847 /* The size of an external RELA relocation.  */
848 #define MIPS_ELF_RELA_SIZE(abfd) \
849   (get_elf_backend_data (abfd)->s->sizeof_rela)
850
851 /* The size of an external dynamic table entry.  */
852 #define MIPS_ELF_DYN_SIZE(abfd) \
853   (get_elf_backend_data (abfd)->s->sizeof_dyn)
854
855 /* The size of a GOT entry.  */
856 #define MIPS_ELF_GOT_SIZE(abfd) \
857   (get_elf_backend_data (abfd)->s->arch_size / 8)
858
859 /* The size of the .rld_map section. */
860 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
861   (get_elf_backend_data (abfd)->s->arch_size / 8)
862
863 /* The size of a symbol-table entry.  */
864 #define MIPS_ELF_SYM_SIZE(abfd) \
865   (get_elf_backend_data (abfd)->s->sizeof_sym)
866
867 /* The default alignment for sections, as a power of two.  */
868 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
869   (get_elf_backend_data (abfd)->s->log_file_align)
870
871 /* Get word-sized data.  */
872 #define MIPS_ELF_GET_WORD(abfd, ptr) \
873   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
874
875 /* Put out word-sized data.  */
876 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
877   (ABI_64_P (abfd)                              \
878    ? bfd_put_64 (abfd, val, ptr)                \
879    : bfd_put_32 (abfd, val, ptr))
880
881 /* The opcode for word-sized loads (LW or LD).  */
882 #define MIPS_ELF_LOAD_WORD(abfd) \
883   (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
884
885 /* Add a dynamic symbol table-entry.  */
886 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
887   _bfd_elf_add_dynamic_entry (info, tag, val)
888
889 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
890   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (abfd, rtype, rela))
891
892 /* The name of the dynamic relocation section.  */
893 #define MIPS_ELF_REL_DYN_NAME(INFO) \
894   (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
895
896 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
897    from smaller values.  Start with zero, widen, *then* decrement.  */
898 #define MINUS_ONE       (((bfd_vma)0) - 1)
899 #define MINUS_TWO       (((bfd_vma)0) - 2)
900
901 /* The value to write into got[1] for SVR4 targets, to identify it is
902    a GNU object.  The dynamic linker can then use got[1] to store the
903    module pointer.  */
904 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
905   ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
906
907 /* The offset of $gp from the beginning of the .got section.  */
908 #define ELF_MIPS_GP_OFFSET(INFO) \
909   (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
910
911 /* The maximum size of the GOT for it to be addressable using 16-bit
912    offsets from $gp.  */
913 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
914
915 /* Instructions which appear in a stub.  */
916 #define STUB_LW(abfd)                                                   \
917   ((ABI_64_P (abfd)                                                     \
918     ? 0xdf998010                                /* ld t9,0x8010(gp) */  \
919     : 0x8f998010))                              /* lw t9,0x8010(gp) */
920 #define STUB_MOVE 0x03e07825                    /* or t7,ra,zero */
921 #define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */
922 #define STUB_JALR 0x0320f809                    /* jalr ra,t9 */
923 #define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */
924 #define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */
925 #define STUB_LI16S(abfd, VAL)                                           \
926    ((ABI_64_P (abfd)                                                    \
927     ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \
928     : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */
929
930 /* Likewise for the microMIPS ASE.  */
931 #define STUB_LW_MICROMIPS(abfd)                                         \
932   (ABI_64_P (abfd)                                                      \
933    ? 0xdf3c8010                                 /* ld t9,0x8010(gp) */  \
934    : 0xff3c8010)                                /* lw t9,0x8010(gp) */
935 #define STUB_MOVE_MICROMIPS 0x0dff              /* move t7,ra */
936 #define STUB_MOVE32_MICROMIPS 0x001f7a90        /* or t7,ra,zero */
937 #define STUB_LUI_MICROMIPS(VAL)                                         \
938    (0x41b80000 + (VAL))                         /* lui t8,VAL */
939 #define STUB_JALR_MICROMIPS 0x45d9              /* jalr t9 */
940 #define STUB_JALR32_MICROMIPS 0x03f90f3c        /* jalr ra,t9 */
941 #define STUB_ORI_MICROMIPS(VAL)                                         \
942   (0x53180000 + (VAL))                          /* ori t8,t8,VAL */
943 #define STUB_LI16U_MICROMIPS(VAL)                                       \
944   (0x53000000 + (VAL))                          /* ori t8,zero,VAL unsigned */
945 #define STUB_LI16S_MICROMIPS(abfd, VAL)                                 \
946    (ABI_64_P (abfd)                                                     \
947     ? 0x5f000000 + (VAL)        /* daddiu t8,zero,VAL sign extended */  \
948     : 0x33000000 + (VAL))       /* addiu t8,zero,VAL sign extended */
949
950 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
951 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
952 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
953 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
954 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
955 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
956
957 /* The name of the dynamic interpreter.  This is put in the .interp
958    section.  */
959
960 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
961    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
962     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
963     : "/usr/lib/libc.so.1")
964
965 #ifdef BFD64
966 #define MNAME(bfd,pre,pos) \
967   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
968 #define ELF_R_SYM(bfd, i)                                       \
969   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
970 #define ELF_R_TYPE(bfd, i)                                      \
971   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
972 #define ELF_R_INFO(bfd, s, t)                                   \
973   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
974 #else
975 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
976 #define ELF_R_SYM(bfd, i)                                       \
977   (ELF32_R_SYM (i))
978 #define ELF_R_TYPE(bfd, i)                                      \
979   (ELF32_R_TYPE (i))
980 #define ELF_R_INFO(bfd, s, t)                                   \
981   (ELF32_R_INFO (s, t))
982 #endif
983 \f
984   /* The mips16 compiler uses a couple of special sections to handle
985      floating point arguments.
986
987      Section names that look like .mips16.fn.FNNAME contain stubs that
988      copy floating point arguments from the fp regs to the gp regs and
989      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
990      call should be redirected to the stub instead.  If no 32 bit
991      function calls FNNAME, the stub should be discarded.  We need to
992      consider any reference to the function, not just a call, because
993      if the address of the function is taken we will need the stub,
994      since the address might be passed to a 32 bit function.
995
996      Section names that look like .mips16.call.FNNAME contain stubs
997      that copy floating point arguments from the gp regs to the fp
998      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
999      then any 16 bit function that calls FNNAME should be redirected
1000      to the stub instead.  If FNNAME is not a 32 bit function, the
1001      stub should be discarded.
1002
1003      .mips16.call.fp.FNNAME sections are similar, but contain stubs
1004      which call FNNAME and then copy the return value from the fp regs
1005      to the gp regs.  These stubs store the return value in $18 while
1006      calling FNNAME; any function which might call one of these stubs
1007      must arrange to save $18 around the call.  (This case is not
1008      needed for 32 bit functions that call 16 bit functions, because
1009      16 bit functions always return floating point values in both
1010      $f0/$f1 and $2/$3.)
1011
1012      Note that in all cases FNNAME might be defined statically.
1013      Therefore, FNNAME is not used literally.  Instead, the relocation
1014      information will indicate which symbol the section is for.
1015
1016      We record any stubs that we find in the symbol table.  */
1017
1018 #define FN_STUB ".mips16.fn."
1019 #define CALL_STUB ".mips16.call."
1020 #define CALL_FP_STUB ".mips16.call.fp."
1021
1022 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1023 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1024 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
1025 \f
1026 /* The format of the first PLT entry in an O32 executable.  */
1027 static const bfd_vma mips_o32_exec_plt0_entry[] =
1028 {
1029   0x3c1c0000,   /* lui $28, %hi(&GOTPLT[0])                             */
1030   0x8f990000,   /* lw $25, %lo(&GOTPLT[0])($28)                         */
1031   0x279c0000,   /* addiu $28, $28, %lo(&GOTPLT[0])                      */
1032   0x031cc023,   /* subu $24, $24, $28                                   */
1033   0x03e07825,   /* or t7, ra, zero                                      */
1034   0x0018c082,   /* srl $24, $24, 2                                      */
1035   0x0320f809,   /* jalr $25                                             */
1036   0x2718fffe    /* subu $24, $24, 2                                     */
1037 };
1038
1039 /* The format of the first PLT entry in an N32 executable.  Different
1040    because gp ($28) is not available; we use t2 ($14) instead.  */
1041 static const bfd_vma mips_n32_exec_plt0_entry[] =
1042 {
1043   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
1044   0x8dd90000,   /* lw $25, %lo(&GOTPLT[0])($14)                         */
1045   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
1046   0x030ec023,   /* subu $24, $24, $14                                   */
1047   0x03e07825,   /* or t7, ra, zero                                      */
1048   0x0018c082,   /* srl $24, $24, 2                                      */
1049   0x0320f809,   /* jalr $25                                             */
1050   0x2718fffe    /* subu $24, $24, 2                                     */
1051 };
1052
1053 /* The format of the first PLT entry in an N64 executable.  Different
1054    from N32 because of the increased size of GOT entries.  */
1055 static const bfd_vma mips_n64_exec_plt0_entry[] =
1056 {
1057   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
1058   0xddd90000,   /* ld $25, %lo(&GOTPLT[0])($14)                         */
1059   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
1060   0x030ec023,   /* subu $24, $24, $14                                   */
1061   0x03e07825,   /* or t7, ra, zero                                      */
1062   0x0018c0c2,   /* srl $24, $24, 3                                      */
1063   0x0320f809,   /* jalr $25                                             */
1064   0x2718fffe    /* subu $24, $24, 2                                     */
1065 };
1066
1067 /* The format of the microMIPS first PLT entry in an O32 executable.
1068    We rely on v0 ($2) rather than t8 ($24) to contain the address
1069    of the GOTPLT entry handled, so this stub may only be used when
1070    all the subsequent PLT entries are microMIPS code too.
1071
1072    The trailing NOP is for alignment and correct disassembly only.  */
1073 static const bfd_vma micromips_o32_exec_plt0_entry[] =
1074 {
1075   0x7980, 0x0000,       /* addiupc $3, (&GOTPLT[0]) - .                 */
1076   0xff23, 0x0000,       /* lw $25, 0($3)                                */
1077   0x0535,               /* subu $2, $2, $3                              */
1078   0x2525,               /* srl $2, $2, 2                                */
1079   0x3302, 0xfffe,       /* subu $24, $2, 2                              */
1080   0x0dff,               /* move $15, $31                                */
1081   0x45f9,               /* jalrs $25                                    */
1082   0x0f83,               /* move $28, $3                                 */
1083   0x0c00                /* nop                                          */
1084 };
1085
1086 /* The format of the microMIPS first PLT entry in an O32 executable
1087    in the insn32 mode.  */
1088 static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] =
1089 {
1090   0x41bc, 0x0000,       /* lui $28, %hi(&GOTPLT[0])                     */
1091   0xff3c, 0x0000,       /* lw $25, %lo(&GOTPLT[0])($28)                 */
1092   0x339c, 0x0000,       /* addiu $28, $28, %lo(&GOTPLT[0])              */
1093   0x0398, 0xc1d0,       /* subu $24, $24, $28                           */
1094   0x001f, 0x7a90,       /* or $15, $31, zero                            */
1095   0x0318, 0x1040,       /* srl $24, $24, 2                              */
1096   0x03f9, 0x0f3c,       /* jalr $25                                     */
1097   0x3318, 0xfffe        /* subu $24, $24, 2                             */
1098 };
1099
1100 /* The format of subsequent standard PLT entries.  */
1101 static const bfd_vma mips_exec_plt_entry[] =
1102 {
1103   0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
1104   0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
1105   0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
1106   0x03200008    /* jr $25                                       */
1107 };
1108
1109 /* In the following PLT entry the JR and ADDIU instructions will
1110    be swapped in _bfd_mips_elf_finish_dynamic_symbol because
1111    LOAD_INTERLOCKS_P will be true for MIPS R6.  */
1112 static const bfd_vma mipsr6_exec_plt_entry[] =
1113 {
1114   0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
1115   0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
1116   0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
1117   0x03200009    /* jr $25                                       */
1118 };
1119
1120 /* The format of subsequent MIPS16 o32 PLT entries.  We use v0 ($2)
1121    and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1122    directly addressable.  */
1123 static const bfd_vma mips16_o32_exec_plt_entry[] =
1124 {
1125   0xb203,               /* lw $2, 12($pc)                       */
1126   0x9a60,               /* lw $3, 0($2)                         */
1127   0x651a,               /* move $24, $2                         */
1128   0xeb00,               /* jr $3                                */
1129   0x653b,               /* move $25, $3                         */
1130   0x6500,               /* nop                                  */
1131   0x0000, 0x0000        /* .word (.got.plt entry)               */
1132 };
1133
1134 /* The format of subsequent microMIPS o32 PLT entries.  We use v0 ($2)
1135    as a temporary because t8 ($24) is not addressable with ADDIUPC.  */
1136 static const bfd_vma micromips_o32_exec_plt_entry[] =
1137 {
1138   0x7900, 0x0000,       /* addiupc $2, (.got.plt entry) - .     */
1139   0xff22, 0x0000,       /* lw $25, 0($2)                        */
1140   0x4599,               /* jr $25                               */
1141   0x0f02                /* move $24, $2                         */
1142 };
1143
1144 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode.  */
1145 static const bfd_vma micromips_insn32_o32_exec_plt_entry[] =
1146 {
1147   0x41af, 0x0000,       /* lui $15, %hi(.got.plt entry)         */
1148   0xff2f, 0x0000,       /* lw $25, %lo(.got.plt entry)($15)     */
1149   0x0019, 0x0f3c,       /* jr $25                               */
1150   0x330f, 0x0000        /* addiu $24, $15, %lo(.got.plt entry)  */
1151 };
1152
1153 /* The format of the first PLT entry in a VxWorks executable.  */
1154 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
1155 {
1156   0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */
1157   0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */
1158   0x8f390008,   /* lw t9, 8(t9)                                 */
1159   0x00000000,   /* nop                                          */
1160   0x03200008,   /* jr t9                                        */
1161   0x00000000    /* nop                                          */
1162 };
1163
1164 /* The format of subsequent PLT entries.  */
1165 static const bfd_vma mips_vxworks_exec_plt_entry[] =
1166 {
1167   0x10000000,   /* b .PLT_resolver                      */
1168   0x24180000,   /* li t8, <pltindex>                    */
1169   0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */
1170   0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */
1171   0x8f390000,   /* lw t9, 0(t9)                         */
1172   0x00000000,   /* nop                                  */
1173   0x03200008,   /* jr t9                                */
1174   0x00000000    /* nop                                  */
1175 };
1176
1177 /* The format of the first PLT entry in a VxWorks shared object.  */
1178 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1179 {
1180   0x8f990008,   /* lw t9, 8(gp)         */
1181   0x00000000,   /* nop                  */
1182   0x03200008,   /* jr t9                */
1183   0x00000000,   /* nop                  */
1184   0x00000000,   /* nop                  */
1185   0x00000000    /* nop                  */
1186 };
1187
1188 /* The format of subsequent PLT entries.  */
1189 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1190 {
1191   0x10000000,   /* b .PLT_resolver      */
1192   0x24180000    /* li t8, <pltindex>    */
1193 };
1194 \f
1195 /* microMIPS 32-bit opcode helper installer.  */
1196
1197 static void
1198 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1199 {
1200   bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1201   bfd_put_16 (abfd,  opcode        & 0xffff, ptr + 2);
1202 }
1203
1204 /* microMIPS 32-bit opcode helper retriever.  */
1205
1206 static bfd_vma
1207 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1208 {
1209   return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1210 }
1211 \f
1212 /* Look up an entry in a MIPS ELF linker hash table.  */
1213
1214 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
1215   ((struct mips_elf_link_hash_entry *)                                  \
1216    elf_link_hash_lookup (&(table)->root, (string), (create),            \
1217                          (copy), (follow)))
1218
1219 /* Traverse a MIPS ELF linker hash table.  */
1220
1221 #define mips_elf_link_hash_traverse(table, func, info)                  \
1222   (elf_link_hash_traverse                                               \
1223    (&(table)->root,                                                     \
1224     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1225     (info)))
1226
1227 /* Find the base offsets for thread-local storage in this object,
1228    for GD/LD and IE/LE respectively.  */
1229
1230 #define TP_OFFSET 0x7000
1231 #define DTP_OFFSET 0x8000
1232
1233 static bfd_vma
1234 dtprel_base (struct bfd_link_info *info)
1235 {
1236   /* If tls_sec is NULL, we should have signalled an error already.  */
1237   if (elf_hash_table (info)->tls_sec == NULL)
1238     return 0;
1239   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1240 }
1241
1242 static bfd_vma
1243 tprel_base (struct bfd_link_info *info)
1244 {
1245   /* If tls_sec is NULL, we should have signalled an error already.  */
1246   if (elf_hash_table (info)->tls_sec == NULL)
1247     return 0;
1248   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1249 }
1250
1251 /* Create an entry in a MIPS ELF linker hash table.  */
1252
1253 static struct bfd_hash_entry *
1254 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1255                             struct bfd_hash_table *table, const char *string)
1256 {
1257   struct mips_elf_link_hash_entry *ret =
1258     (struct mips_elf_link_hash_entry *) entry;
1259
1260   /* Allocate the structure if it has not already been allocated by a
1261      subclass.  */
1262   if (ret == NULL)
1263     ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1264   if (ret == NULL)
1265     return (struct bfd_hash_entry *) ret;
1266
1267   /* Call the allocation method of the superclass.  */
1268   ret = ((struct mips_elf_link_hash_entry *)
1269          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1270                                      table, string));
1271   if (ret != NULL)
1272     {
1273       /* Set local fields.  */
1274       memset (&ret->esym, 0, sizeof (EXTR));
1275       /* We use -2 as a marker to indicate that the information has
1276          not been set.  -1 means there is no associated ifd.  */
1277       ret->esym.ifd = -2;
1278       ret->la25_stub = 0;
1279       ret->possibly_dynamic_relocs = 0;
1280       ret->fn_stub = NULL;
1281       ret->call_stub = NULL;
1282       ret->call_fp_stub = NULL;
1283       ret->global_got_area = GGA_NONE;
1284       ret->got_only_for_calls = TRUE;
1285       ret->readonly_reloc = FALSE;
1286       ret->has_static_relocs = FALSE;
1287       ret->no_fn_stub = FALSE;
1288       ret->need_fn_stub = FALSE;
1289       ret->has_nonpic_branches = FALSE;
1290       ret->needs_lazy_stub = FALSE;
1291       ret->use_plt_entry = FALSE;
1292     }
1293
1294   return (struct bfd_hash_entry *) ret;
1295 }
1296
1297 /* Allocate MIPS ELF private object data.  */
1298
1299 bfd_boolean
1300 _bfd_mips_elf_mkobject (bfd *abfd)
1301 {
1302   return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
1303                                   MIPS_ELF_DATA);
1304 }
1305
1306 bfd_boolean
1307 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1308 {
1309   if (!sec->used_by_bfd)
1310     {
1311       struct _mips_elf_section_data *sdata;
1312       bfd_size_type amt = sizeof (*sdata);
1313
1314       sdata = bfd_zalloc (abfd, amt);
1315       if (sdata == NULL)
1316         return FALSE;
1317       sec->used_by_bfd = sdata;
1318     }
1319
1320   return _bfd_elf_new_section_hook (abfd, sec);
1321 }
1322 \f
1323 /* Read ECOFF debugging information from a .mdebug section into a
1324    ecoff_debug_info structure.  */
1325
1326 bfd_boolean
1327 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1328                                struct ecoff_debug_info *debug)
1329 {
1330   HDRR *symhdr;
1331   const struct ecoff_debug_swap *swap;
1332   char *ext_hdr;
1333
1334   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1335   memset (debug, 0, sizeof (*debug));
1336
1337   ext_hdr = bfd_malloc (swap->external_hdr_size);
1338   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1339     goto error_return;
1340
1341   if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1342                                   swap->external_hdr_size))
1343     goto error_return;
1344
1345   symhdr = &debug->symbolic_header;
1346   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1347
1348   /* The symbolic header contains absolute file offsets and sizes to
1349      read.  */
1350 #define READ(ptr, offset, count, size, type)                            \
1351   if (symhdr->count == 0)                                               \
1352     debug->ptr = NULL;                                                  \
1353   else                                                                  \
1354     {                                                                   \
1355       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1356       debug->ptr = bfd_malloc (amt);                                    \
1357       if (debug->ptr == NULL)                                           \
1358         goto error_return;                                              \
1359       if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0                \
1360           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1361         goto error_return;                                              \
1362     }
1363
1364   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1365   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1366   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1367   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1368   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1369   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1370         union aux_ext *);
1371   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1372   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1373   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1374   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1375   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1376 #undef READ
1377
1378   debug->fdr = NULL;
1379
1380   return TRUE;
1381
1382  error_return:
1383   if (ext_hdr != NULL)
1384     free (ext_hdr);
1385   if (debug->line != NULL)
1386     free (debug->line);
1387   if (debug->external_dnr != NULL)
1388     free (debug->external_dnr);
1389   if (debug->external_pdr != NULL)
1390     free (debug->external_pdr);
1391   if (debug->external_sym != NULL)
1392     free (debug->external_sym);
1393   if (debug->external_opt != NULL)
1394     free (debug->external_opt);
1395   if (debug->external_aux != NULL)
1396     free (debug->external_aux);
1397   if (debug->ss != NULL)
1398     free (debug->ss);
1399   if (debug->ssext != NULL)
1400     free (debug->ssext);
1401   if (debug->external_fdr != NULL)
1402     free (debug->external_fdr);
1403   if (debug->external_rfd != NULL)
1404     free (debug->external_rfd);
1405   if (debug->external_ext != NULL)
1406     free (debug->external_ext);
1407   return FALSE;
1408 }
1409 \f
1410 /* Swap RPDR (runtime procedure table entry) for output.  */
1411
1412 static void
1413 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1414 {
1415   H_PUT_S32 (abfd, in->adr, ex->p_adr);
1416   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1417   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1418   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1419   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1420   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1421
1422   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1423   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1424
1425   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1426 }
1427
1428 /* Create a runtime procedure table from the .mdebug section.  */
1429
1430 static bfd_boolean
1431 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1432                                  struct bfd_link_info *info, asection *s,
1433                                  struct ecoff_debug_info *debug)
1434 {
1435   const struct ecoff_debug_swap *swap;
1436   HDRR *hdr = &debug->symbolic_header;
1437   RPDR *rpdr, *rp;
1438   struct rpdr_ext *erp;
1439   void *rtproc;
1440   struct pdr_ext *epdr;
1441   struct sym_ext *esym;
1442   char *ss, **sv;
1443   char *str;
1444   bfd_size_type size;
1445   bfd_size_type count;
1446   unsigned long sindex;
1447   unsigned long i;
1448   PDR pdr;
1449   SYMR sym;
1450   const char *no_name_func = _("static procedure (no name)");
1451
1452   epdr = NULL;
1453   rpdr = NULL;
1454   esym = NULL;
1455   ss = NULL;
1456   sv = NULL;
1457
1458   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1459
1460   sindex = strlen (no_name_func) + 1;
1461   count = hdr->ipdMax;
1462   if (count > 0)
1463     {
1464       size = swap->external_pdr_size;
1465
1466       epdr = bfd_malloc (size * count);
1467       if (epdr == NULL)
1468         goto error_return;
1469
1470       if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1471         goto error_return;
1472
1473       size = sizeof (RPDR);
1474       rp = rpdr = bfd_malloc (size * count);
1475       if (rpdr == NULL)
1476         goto error_return;
1477
1478       size = sizeof (char *);
1479       sv = bfd_malloc (size * count);
1480       if (sv == NULL)
1481         goto error_return;
1482
1483       count = hdr->isymMax;
1484       size = swap->external_sym_size;
1485       esym = bfd_malloc (size * count);
1486       if (esym == NULL)
1487         goto error_return;
1488
1489       if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1490         goto error_return;
1491
1492       count = hdr->issMax;
1493       ss = bfd_malloc (count);
1494       if (ss == NULL)
1495         goto error_return;
1496       if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1497         goto error_return;
1498
1499       count = hdr->ipdMax;
1500       for (i = 0; i < (unsigned long) count; i++, rp++)
1501         {
1502           (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1503           (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1504           rp->adr = sym.value;
1505           rp->regmask = pdr.regmask;
1506           rp->regoffset = pdr.regoffset;
1507           rp->fregmask = pdr.fregmask;
1508           rp->fregoffset = pdr.fregoffset;
1509           rp->frameoffset = pdr.frameoffset;
1510           rp->framereg = pdr.framereg;
1511           rp->pcreg = pdr.pcreg;
1512           rp->irpss = sindex;
1513           sv[i] = ss + sym.iss;
1514           sindex += strlen (sv[i]) + 1;
1515         }
1516     }
1517
1518   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1519   size = BFD_ALIGN (size, 16);
1520   rtproc = bfd_alloc (abfd, size);
1521   if (rtproc == NULL)
1522     {
1523       mips_elf_hash_table (info)->procedure_count = 0;
1524       goto error_return;
1525     }
1526
1527   mips_elf_hash_table (info)->procedure_count = count + 2;
1528
1529   erp = rtproc;
1530   memset (erp, 0, sizeof (struct rpdr_ext));
1531   erp++;
1532   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1533   strcpy (str, no_name_func);
1534   str += strlen (no_name_func) + 1;
1535   for (i = 0; i < count; i++)
1536     {
1537       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1538       strcpy (str, sv[i]);
1539       str += strlen (sv[i]) + 1;
1540     }
1541   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1542
1543   /* Set the size and contents of .rtproc section.  */
1544   s->size = size;
1545   s->contents = rtproc;
1546
1547   /* Skip this section later on (I don't think this currently
1548      matters, but someday it might).  */
1549   s->map_head.link_order = NULL;
1550
1551   if (epdr != NULL)
1552     free (epdr);
1553   if (rpdr != NULL)
1554     free (rpdr);
1555   if (esym != NULL)
1556     free (esym);
1557   if (ss != NULL)
1558     free (ss);
1559   if (sv != NULL)
1560     free (sv);
1561
1562   return TRUE;
1563
1564  error_return:
1565   if (epdr != NULL)
1566     free (epdr);
1567   if (rpdr != NULL)
1568     free (rpdr);
1569   if (esym != NULL)
1570     free (esym);
1571   if (ss != NULL)
1572     free (ss);
1573   if (sv != NULL)
1574     free (sv);
1575   return FALSE;
1576 }
1577 \f
1578 /* We're going to create a stub for H.  Create a symbol for the stub's
1579    value and size, to help make the disassembly easier to read.  */
1580
1581 static bfd_boolean
1582 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1583                              struct mips_elf_link_hash_entry *h,
1584                              const char *prefix, asection *s, bfd_vma value,
1585                              bfd_vma size)
1586 {
1587   bfd_boolean micromips_p = ELF_ST_IS_MICROMIPS (h->root.other);
1588   struct bfd_link_hash_entry *bh;
1589   struct elf_link_hash_entry *elfh;
1590   char *name;
1591   bfd_boolean res;
1592
1593   if (micromips_p)
1594     value |= 1;
1595
1596   /* Create a new symbol.  */
1597   name = concat (prefix, h->root.root.root.string, NULL);
1598   bh = NULL;
1599   res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1600                                           BSF_LOCAL, s, value, NULL,
1601                                           TRUE, FALSE, &bh);
1602   free (name);
1603   if (! res)
1604     return FALSE;
1605
1606   /* Make it a local function.  */
1607   elfh = (struct elf_link_hash_entry *) bh;
1608   elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1609   elfh->size = size;
1610   elfh->forced_local = 1;
1611   if (micromips_p)
1612     elfh->other = ELF_ST_SET_MICROMIPS (elfh->other);
1613   return TRUE;
1614 }
1615
1616 /* We're about to redefine H.  Create a symbol to represent H's
1617    current value and size, to help make the disassembly easier
1618    to read.  */
1619
1620 static bfd_boolean
1621 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1622                                struct mips_elf_link_hash_entry *h,
1623                                const char *prefix)
1624 {
1625   struct bfd_link_hash_entry *bh;
1626   struct elf_link_hash_entry *elfh;
1627   char *name;
1628   asection *s;
1629   bfd_vma value;
1630   bfd_boolean res;
1631
1632   /* Read the symbol's value.  */
1633   BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1634               || h->root.root.type == bfd_link_hash_defweak);
1635   s = h->root.root.u.def.section;
1636   value = h->root.root.u.def.value;
1637
1638   /* Create a new symbol.  */
1639   name = concat (prefix, h->root.root.root.string, NULL);
1640   bh = NULL;
1641   res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1642                                           BSF_LOCAL, s, value, NULL,
1643                                           TRUE, FALSE, &bh);
1644   free (name);
1645   if (! res)
1646     return FALSE;
1647
1648   /* Make it local and copy the other attributes from H.  */
1649   elfh = (struct elf_link_hash_entry *) bh;
1650   elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1651   elfh->other = h->root.other;
1652   elfh->size = h->root.size;
1653   elfh->forced_local = 1;
1654   return TRUE;
1655 }
1656
1657 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1658    function rather than to a hard-float stub.  */
1659
1660 static bfd_boolean
1661 section_allows_mips16_refs_p (asection *section)
1662 {
1663   const char *name;
1664
1665   name = bfd_get_section_name (section->owner, section);
1666   return (FN_STUB_P (name)
1667           || CALL_STUB_P (name)
1668           || CALL_FP_STUB_P (name)
1669           || strcmp (name, ".pdr") == 0);
1670 }
1671
1672 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1673    stub section of some kind.  Return the R_SYMNDX of the target
1674    function, or 0 if we can't decide which function that is.  */
1675
1676 static unsigned long
1677 mips16_stub_symndx (const struct elf_backend_data *bed,
1678                     asection *sec ATTRIBUTE_UNUSED,
1679                     const Elf_Internal_Rela *relocs,
1680                     const Elf_Internal_Rela *relend)
1681 {
1682   int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
1683   const Elf_Internal_Rela *rel;
1684
1685   /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1686      one in a compound relocation.  */
1687   for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
1688     if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1689       return ELF_R_SYM (sec->owner, rel->r_info);
1690
1691   /* Otherwise trust the first relocation, whatever its kind.  This is
1692      the traditional behavior.  */
1693   if (relocs < relend)
1694     return ELF_R_SYM (sec->owner, relocs->r_info);
1695
1696   return 0;
1697 }
1698
1699 /* Check the mips16 stubs for a particular symbol, and see if we can
1700    discard them.  */
1701
1702 static void
1703 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1704                              struct mips_elf_link_hash_entry *h)
1705 {
1706   /* Dynamic symbols must use the standard call interface, in case other
1707      objects try to call them.  */
1708   if (h->fn_stub != NULL
1709       && h->root.dynindx != -1)
1710     {
1711       mips_elf_create_shadow_symbol (info, h, ".mips16.");
1712       h->need_fn_stub = TRUE;
1713     }
1714
1715   if (h->fn_stub != NULL
1716       && ! h->need_fn_stub)
1717     {
1718       /* We don't need the fn_stub; the only references to this symbol
1719          are 16 bit calls.  Clobber the size to 0 to prevent it from
1720          being included in the link.  */
1721       h->fn_stub->size = 0;
1722       h->fn_stub->flags &= ~SEC_RELOC;
1723       h->fn_stub->reloc_count = 0;
1724       h->fn_stub->flags |= SEC_EXCLUDE;
1725       h->fn_stub->output_section = bfd_abs_section_ptr;
1726     }
1727
1728   if (h->call_stub != NULL
1729       && ELF_ST_IS_MIPS16 (h->root.other))
1730     {
1731       /* We don't need the call_stub; this is a 16 bit function, so
1732          calls from other 16 bit functions are OK.  Clobber the size
1733          to 0 to prevent it from being included in the link.  */
1734       h->call_stub->size = 0;
1735       h->call_stub->flags &= ~SEC_RELOC;
1736       h->call_stub->reloc_count = 0;
1737       h->call_stub->flags |= SEC_EXCLUDE;
1738       h->call_stub->output_section = bfd_abs_section_ptr;
1739     }
1740
1741   if (h->call_fp_stub != NULL
1742       && ELF_ST_IS_MIPS16 (h->root.other))
1743     {
1744       /* We don't need the call_stub; this is a 16 bit function, so
1745          calls from other 16 bit functions are OK.  Clobber the size
1746          to 0 to prevent it from being included in the link.  */
1747       h->call_fp_stub->size = 0;
1748       h->call_fp_stub->flags &= ~SEC_RELOC;
1749       h->call_fp_stub->reloc_count = 0;
1750       h->call_fp_stub->flags |= SEC_EXCLUDE;
1751       h->call_fp_stub->output_section = bfd_abs_section_ptr;
1752     }
1753 }
1754
1755 /* Hashtable callbacks for mips_elf_la25_stubs.  */
1756
1757 static hashval_t
1758 mips_elf_la25_stub_hash (const void *entry_)
1759 {
1760   const struct mips_elf_la25_stub *entry;
1761
1762   entry = (struct mips_elf_la25_stub *) entry_;
1763   return entry->h->root.root.u.def.section->id
1764     + entry->h->root.root.u.def.value;
1765 }
1766
1767 static int
1768 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1769 {
1770   const struct mips_elf_la25_stub *entry1, *entry2;
1771
1772   entry1 = (struct mips_elf_la25_stub *) entry1_;
1773   entry2 = (struct mips_elf_la25_stub *) entry2_;
1774   return ((entry1->h->root.root.u.def.section
1775            == entry2->h->root.root.u.def.section)
1776           && (entry1->h->root.root.u.def.value
1777               == entry2->h->root.root.u.def.value));
1778 }
1779
1780 /* Called by the linker to set up the la25 stub-creation code.  FN is
1781    the linker's implementation of add_stub_function.  Return true on
1782    success.  */
1783
1784 bfd_boolean
1785 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1786                           asection *(*fn) (const char *, asection *,
1787                                            asection *))
1788 {
1789   struct mips_elf_link_hash_table *htab;
1790
1791   htab = mips_elf_hash_table (info);
1792   if (htab == NULL)
1793     return FALSE;
1794
1795   htab->add_stub_section = fn;
1796   htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1797                                       mips_elf_la25_stub_eq, NULL);
1798   if (htab->la25_stubs == NULL)
1799     return FALSE;
1800
1801   return TRUE;
1802 }
1803
1804 /* Return true if H is a locally-defined PIC function, in the sense
1805    that it or its fn_stub might need $25 to be valid on entry.
1806    Note that MIPS16 functions set up $gp using PC-relative instructions,
1807    so they themselves never need $25 to be valid.  Only non-MIPS16
1808    entry points are of interest here.  */
1809
1810 static bfd_boolean
1811 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1812 {
1813   return ((h->root.root.type == bfd_link_hash_defined
1814            || h->root.root.type == bfd_link_hash_defweak)
1815           && h->root.def_regular
1816           && !bfd_is_abs_section (h->root.root.u.def.section)
1817           && !bfd_is_und_section (h->root.root.u.def.section)
1818           && (!ELF_ST_IS_MIPS16 (h->root.other)
1819               || (h->fn_stub && h->need_fn_stub))
1820           && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1821               || ELF_ST_IS_MIPS_PIC (h->root.other)));
1822 }
1823
1824 /* Set *SEC to the input section that contains the target of STUB.
1825    Return the offset of the target from the start of that section.  */
1826
1827 static bfd_vma
1828 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1829                           asection **sec)
1830 {
1831   if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1832     {
1833       BFD_ASSERT (stub->h->need_fn_stub);
1834       *sec = stub->h->fn_stub;
1835       return 0;
1836     }
1837   else
1838     {
1839       *sec = stub->h->root.root.u.def.section;
1840       return stub->h->root.root.u.def.value;
1841     }
1842 }
1843
1844 /* STUB describes an la25 stub that we have decided to implement
1845    by inserting an LUI/ADDIU pair before the target function.
1846    Create the section and redirect the function symbol to it.  */
1847
1848 static bfd_boolean
1849 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1850                          struct bfd_link_info *info)
1851 {
1852   struct mips_elf_link_hash_table *htab;
1853   char *name;
1854   asection *s, *input_section;
1855   unsigned int align;
1856
1857   htab = mips_elf_hash_table (info);
1858   if (htab == NULL)
1859     return FALSE;
1860
1861   /* Create a unique name for the new section.  */
1862   name = bfd_malloc (11 + sizeof (".text.stub."));
1863   if (name == NULL)
1864     return FALSE;
1865   sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1866
1867   /* Create the section.  */
1868   mips_elf_get_la25_target (stub, &input_section);
1869   s = htab->add_stub_section (name, input_section,
1870                               input_section->output_section);
1871   if (s == NULL)
1872     return FALSE;
1873
1874   /* Make sure that any padding goes before the stub.  */
1875   align = input_section->alignment_power;
1876   if (!bfd_set_section_alignment (s->owner, s, align))
1877     return FALSE;
1878   if (align > 3)
1879     s->size = (1 << align) - 8;
1880
1881   /* Create a symbol for the stub.  */
1882   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1883   stub->stub_section = s;
1884   stub->offset = s->size;
1885
1886   /* Allocate room for it.  */
1887   s->size += 8;
1888   return TRUE;
1889 }
1890
1891 /* STUB describes an la25 stub that we have decided to implement
1892    with a separate trampoline.  Allocate room for it and redirect
1893    the function symbol to it.  */
1894
1895 static bfd_boolean
1896 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1897                               struct bfd_link_info *info)
1898 {
1899   struct mips_elf_link_hash_table *htab;
1900   asection *s;
1901
1902   htab = mips_elf_hash_table (info);
1903   if (htab == NULL)
1904     return FALSE;
1905
1906   /* Create a trampoline section, if we haven't already.  */
1907   s = htab->strampoline;
1908   if (s == NULL)
1909     {
1910       asection *input_section = stub->h->root.root.u.def.section;
1911       s = htab->add_stub_section (".text", NULL,
1912                                   input_section->output_section);
1913       if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1914         return FALSE;
1915       htab->strampoline = s;
1916     }
1917
1918   /* Create a symbol for the stub.  */
1919   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1920   stub->stub_section = s;
1921   stub->offset = s->size;
1922
1923   /* Allocate room for it.  */
1924   s->size += 16;
1925   return TRUE;
1926 }
1927
1928 /* H describes a symbol that needs an la25 stub.  Make sure that an
1929    appropriate stub exists and point H at it.  */
1930
1931 static bfd_boolean
1932 mips_elf_add_la25_stub (struct bfd_link_info *info,
1933                         struct mips_elf_link_hash_entry *h)
1934 {
1935   struct mips_elf_link_hash_table *htab;
1936   struct mips_elf_la25_stub search, *stub;
1937   bfd_boolean use_trampoline_p;
1938   asection *s;
1939   bfd_vma value;
1940   void **slot;
1941
1942   /* Describe the stub we want.  */
1943   search.stub_section = NULL;
1944   search.offset = 0;
1945   search.h = h;
1946
1947   /* See if we've already created an equivalent stub.  */
1948   htab = mips_elf_hash_table (info);
1949   if (htab == NULL)
1950     return FALSE;
1951
1952   slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1953   if (slot == NULL)
1954     return FALSE;
1955
1956   stub = (struct mips_elf_la25_stub *) *slot;
1957   if (stub != NULL)
1958     {
1959       /* We can reuse the existing stub.  */
1960       h->la25_stub = stub;
1961       return TRUE;
1962     }
1963
1964   /* Create a permanent copy of ENTRY and add it to the hash table.  */
1965   stub = bfd_malloc (sizeof (search));
1966   if (stub == NULL)
1967     return FALSE;
1968   *stub = search;
1969   *slot = stub;
1970
1971   /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1972      of the section and if we would need no more than 2 nops.  */
1973   value = mips_elf_get_la25_target (stub, &s);
1974   if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
1975     value &= ~1;
1976   use_trampoline_p = (value != 0 || s->alignment_power > 4);
1977
1978   h->la25_stub = stub;
1979   return (use_trampoline_p
1980           ? mips_elf_add_la25_trampoline (stub, info)
1981           : mips_elf_add_la25_intro (stub, info));
1982 }
1983
1984 /* A mips_elf_link_hash_traverse callback that is called before sizing
1985    sections.  DATA points to a mips_htab_traverse_info structure.  */
1986
1987 static bfd_boolean
1988 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1989 {
1990   struct mips_htab_traverse_info *hti;
1991
1992   hti = (struct mips_htab_traverse_info *) data;
1993   if (!bfd_link_relocatable (hti->info))
1994     mips_elf_check_mips16_stubs (hti->info, h);
1995
1996   if (mips_elf_local_pic_function_p (h))
1997     {
1998       /* PR 12845: If H is in a section that has been garbage
1999          collected it will have its output section set to *ABS*.  */
2000       if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
2001         return TRUE;
2002
2003       /* H is a function that might need $25 to be valid on entry.
2004          If we're creating a non-PIC relocatable object, mark H as
2005          being PIC.  If we're creating a non-relocatable object with
2006          non-PIC branches and jumps to H, make sure that H has an la25
2007          stub.  */
2008       if (bfd_link_relocatable (hti->info))
2009         {
2010           if (!PIC_OBJECT_P (hti->output_bfd))
2011             h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
2012         }
2013       else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
2014         {
2015           hti->error = TRUE;
2016           return FALSE;
2017         }
2018     }
2019   return TRUE;
2020 }
2021 \f
2022 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2023    Most mips16 instructions are 16 bits, but these instructions
2024    are 32 bits.
2025
2026    The format of these instructions is:
2027
2028    +--------------+--------------------------------+
2029    |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
2030    +--------------+--------------------------------+
2031    |                Immediate  15:0                |
2032    +-----------------------------------------------+
2033
2034    JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
2035    Note that the immediate value in the first word is swapped.
2036
2037    When producing a relocatable object file, R_MIPS16_26 is
2038    handled mostly like R_MIPS_26.  In particular, the addend is
2039    stored as a straight 26-bit value in a 32-bit instruction.
2040    (gas makes life simpler for itself by never adjusting a
2041    R_MIPS16_26 reloc to be against a section, so the addend is
2042    always zero).  However, the 32 bit instruction is stored as 2
2043    16-bit values, rather than a single 32-bit value.  In a
2044    big-endian file, the result is the same; in a little-endian
2045    file, the two 16-bit halves of the 32 bit value are swapped.
2046    This is so that a disassembler can recognize the jal
2047    instruction.
2048
2049    When doing a final link, R_MIPS16_26 is treated as a 32 bit
2050    instruction stored as two 16-bit values.  The addend A is the
2051    contents of the targ26 field.  The calculation is the same as
2052    R_MIPS_26.  When storing the calculated value, reorder the
2053    immediate value as shown above, and don't forget to store the
2054    value as two 16-bit values.
2055
2056    To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2057    defined as
2058
2059    big-endian:
2060    +--------+----------------------+
2061    |        |                      |
2062    |        |    targ26-16         |
2063    |31    26|25                   0|
2064    +--------+----------------------+
2065
2066    little-endian:
2067    +----------+------+-------------+
2068    |          |      |             |
2069    |  sub1    |      |     sub2    |
2070    |0        9|10  15|16         31|
2071    +----------+--------------------+
2072    where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2073    ((sub1 << 16) | sub2)).
2074
2075    When producing a relocatable object file, the calculation is
2076    (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2077    When producing a fully linked file, the calculation is
2078    let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2079    ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2080
2081    The table below lists the other MIPS16 instruction relocations.
2082    Each one is calculated in the same way as the non-MIPS16 relocation
2083    given on the right, but using the extended MIPS16 layout of 16-bit
2084    immediate fields:
2085
2086         R_MIPS16_GPREL          R_MIPS_GPREL16
2087         R_MIPS16_GOT16          R_MIPS_GOT16
2088         R_MIPS16_CALL16         R_MIPS_CALL16
2089         R_MIPS16_HI16           R_MIPS_HI16
2090         R_MIPS16_LO16           R_MIPS_LO16
2091
2092    A typical instruction will have a format like this:
2093
2094    +--------------+--------------------------------+
2095    |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
2096    +--------------+--------------------------------+
2097    |    Major     |   rx   |   ry   |   Imm  4:0   |
2098    +--------------+--------------------------------+
2099
2100    EXTEND is the five bit value 11110.  Major is the instruction
2101    opcode.
2102
2103    All we need to do here is shuffle the bits appropriately.
2104    As above, the two 16-bit halves must be swapped on a
2105    little-endian system.
2106
2107    Finally R_MIPS16_PC16_S1 corresponds to R_MIPS_PC16, however the
2108    relocatable field is shifted by 1 rather than 2 and the same bit
2109    shuffling is done as with the relocations above.  */
2110
2111 static inline bfd_boolean
2112 mips16_reloc_p (int r_type)
2113 {
2114   switch (r_type)
2115     {
2116     case R_MIPS16_26:
2117     case R_MIPS16_GPREL:
2118     case R_MIPS16_GOT16:
2119     case R_MIPS16_CALL16:
2120     case R_MIPS16_HI16:
2121     case R_MIPS16_LO16:
2122     case R_MIPS16_TLS_GD:
2123     case R_MIPS16_TLS_LDM:
2124     case R_MIPS16_TLS_DTPREL_HI16:
2125     case R_MIPS16_TLS_DTPREL_LO16:
2126     case R_MIPS16_TLS_GOTTPREL:
2127     case R_MIPS16_TLS_TPREL_HI16:
2128     case R_MIPS16_TLS_TPREL_LO16:
2129     case R_MIPS16_PC16_S1:
2130       return TRUE;
2131
2132     default:
2133       return FALSE;
2134     }
2135 }
2136
2137 /* Check if a microMIPS reloc.  */
2138
2139 static inline bfd_boolean
2140 micromips_reloc_p (unsigned int r_type)
2141 {
2142   return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
2143 }
2144
2145 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2146    on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
2147    and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.  */
2148
2149 static inline bfd_boolean
2150 micromips_reloc_shuffle_p (unsigned int r_type)
2151 {
2152   return (micromips_reloc_p (r_type)
2153           && r_type != R_MICROMIPS_PC7_S1
2154           && r_type != R_MICROMIPS_PC10_S1);
2155 }
2156
2157 static inline bfd_boolean
2158 got16_reloc_p (int r_type)
2159 {
2160   return (r_type == R_MIPS_GOT16
2161           || r_type == R_MIPS16_GOT16
2162           || r_type == R_MICROMIPS_GOT16);
2163 }
2164
2165 static inline bfd_boolean
2166 call16_reloc_p (int r_type)
2167 {
2168   return (r_type == R_MIPS_CALL16
2169           || r_type == R_MIPS16_CALL16
2170           || r_type == R_MICROMIPS_CALL16);
2171 }
2172
2173 static inline bfd_boolean
2174 got_disp_reloc_p (unsigned int r_type)
2175 {
2176   return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
2177 }
2178
2179 static inline bfd_boolean
2180 got_page_reloc_p (unsigned int r_type)
2181 {
2182   return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
2183 }
2184
2185 static inline bfd_boolean
2186 got_lo16_reloc_p (unsigned int r_type)
2187 {
2188   return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
2189 }
2190
2191 static inline bfd_boolean
2192 call_hi16_reloc_p (unsigned int r_type)
2193 {
2194   return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2195 }
2196
2197 static inline bfd_boolean
2198 call_lo16_reloc_p (unsigned int r_type)
2199 {
2200   return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
2201 }
2202
2203 static inline bfd_boolean
2204 hi16_reloc_p (int r_type)
2205 {
2206   return (r_type == R_MIPS_HI16
2207           || r_type == R_MIPS16_HI16
2208           || r_type == R_MICROMIPS_HI16
2209           || r_type == R_MIPS_PCHI16);
2210 }
2211
2212 static inline bfd_boolean
2213 lo16_reloc_p (int r_type)
2214 {
2215   return (r_type == R_MIPS_LO16
2216           || r_type == R_MIPS16_LO16
2217           || r_type == R_MICROMIPS_LO16
2218           || r_type == R_MIPS_PCLO16);
2219 }
2220
2221 static inline bfd_boolean
2222 mips16_call_reloc_p (int r_type)
2223 {
2224   return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2225 }
2226
2227 static inline bfd_boolean
2228 jal_reloc_p (int r_type)
2229 {
2230   return (r_type == R_MIPS_26
2231           || r_type == R_MIPS16_26
2232           || r_type == R_MICROMIPS_26_S1);
2233 }
2234
2235 static inline bfd_boolean
2236 b_reloc_p (int r_type)
2237 {
2238   return (r_type == R_MIPS_PC26_S2
2239           || r_type == R_MIPS_PC21_S2
2240           || r_type == R_MIPS_PC16
2241           || r_type == R_MIPS_GNU_REL16_S2
2242           || r_type == R_MIPS16_PC16_S1
2243           || r_type == R_MICROMIPS_PC16_S1
2244           || r_type == R_MICROMIPS_PC10_S1
2245           || r_type == R_MICROMIPS_PC7_S1);
2246 }
2247
2248 static inline bfd_boolean
2249 aligned_pcrel_reloc_p (int r_type)
2250 {
2251   return (r_type == R_MIPS_PC18_S3
2252           || r_type == R_MIPS_PC19_S2);
2253 }
2254
2255 static inline bfd_boolean
2256 branch_reloc_p (int r_type)
2257 {
2258   return (r_type == R_MIPS_26
2259           || r_type == R_MIPS_PC26_S2
2260           || r_type == R_MIPS_PC21_S2
2261           || r_type == R_MIPS_PC16
2262           || r_type == R_MIPS_GNU_REL16_S2);
2263 }
2264
2265 static inline bfd_boolean
2266 mips16_branch_reloc_p (int r_type)
2267 {
2268   return (r_type == R_MIPS16_26
2269           || r_type == R_MIPS16_PC16_S1);
2270 }
2271
2272 static inline bfd_boolean
2273 micromips_branch_reloc_p (int r_type)
2274 {
2275   return (r_type == R_MICROMIPS_26_S1
2276           || r_type == R_MICROMIPS_PC16_S1
2277           || r_type == R_MICROMIPS_PC10_S1
2278           || r_type == R_MICROMIPS_PC7_S1);
2279 }
2280
2281 static inline bfd_boolean
2282 tls_gd_reloc_p (unsigned int r_type)
2283 {
2284   return (r_type == R_MIPS_TLS_GD
2285           || r_type == R_MIPS16_TLS_GD
2286           || r_type == R_MICROMIPS_TLS_GD);
2287 }
2288
2289 static inline bfd_boolean
2290 tls_ldm_reloc_p (unsigned int r_type)
2291 {
2292   return (r_type == R_MIPS_TLS_LDM
2293           || r_type == R_MIPS16_TLS_LDM
2294           || r_type == R_MICROMIPS_TLS_LDM);
2295 }
2296
2297 static inline bfd_boolean
2298 tls_gottprel_reloc_p (unsigned int r_type)
2299 {
2300   return (r_type == R_MIPS_TLS_GOTTPREL
2301           || r_type == R_MIPS16_TLS_GOTTPREL
2302           || r_type == R_MICROMIPS_TLS_GOTTPREL);
2303 }
2304
2305 void
2306 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2307                                bfd_boolean jal_shuffle, bfd_byte *data)
2308 {
2309   bfd_vma first, second, val;
2310
2311   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2312     return;
2313
2314   /* Pick up the first and second halfwords of the instruction.  */
2315   first = bfd_get_16 (abfd, data);
2316   second = bfd_get_16 (abfd, data + 2);
2317   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2318     val = first << 16 | second;
2319   else if (r_type != R_MIPS16_26)
2320     val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2321            | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2322   else
2323     val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2324            | ((first & 0x1f) << 21) | second);
2325   bfd_put_32 (abfd, val, data);
2326 }
2327
2328 void
2329 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2330                              bfd_boolean jal_shuffle, bfd_byte *data)
2331 {
2332   bfd_vma first, second, val;
2333
2334   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2335     return;
2336
2337   val = bfd_get_32 (abfd, data);
2338   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2339     {
2340       second = val & 0xffff;
2341       first = val >> 16;
2342     }
2343   else if (r_type != R_MIPS16_26)
2344     {
2345       second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2346       first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2347     }
2348   else
2349     {
2350       second = val & 0xffff;
2351       first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2352                | ((val >> 21) & 0x1f);
2353     }
2354   bfd_put_16 (abfd, second, data + 2);
2355   bfd_put_16 (abfd, first, data);
2356 }
2357
2358 bfd_reloc_status_type
2359 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2360                                arelent *reloc_entry, asection *input_section,
2361                                bfd_boolean relocatable, void *data, bfd_vma gp)
2362 {
2363   bfd_vma relocation;
2364   bfd_signed_vma val;
2365   bfd_reloc_status_type status;
2366
2367   if (bfd_is_com_section (symbol->section))
2368     relocation = 0;
2369   else
2370     relocation = symbol->value;
2371
2372   relocation += symbol->section->output_section->vma;
2373   relocation += symbol->section->output_offset;
2374
2375   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2376     return bfd_reloc_outofrange;
2377
2378   /* Set val to the offset into the section or symbol.  */
2379   val = reloc_entry->addend;
2380
2381   _bfd_mips_elf_sign_extend (val, 16);
2382
2383   /* Adjust val for the final section location and GP value.  If we
2384      are producing relocatable output, we don't want to do this for
2385      an external symbol.  */
2386   if (! relocatable
2387       || (symbol->flags & BSF_SECTION_SYM) != 0)
2388     val += relocation - gp;
2389
2390   if (reloc_entry->howto->partial_inplace)
2391     {
2392       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2393                                        (bfd_byte *) data
2394                                        + reloc_entry->address);
2395       if (status != bfd_reloc_ok)
2396         return status;
2397     }
2398   else
2399     reloc_entry->addend = val;
2400
2401   if (relocatable)
2402     reloc_entry->address += input_section->output_offset;
2403
2404   return bfd_reloc_ok;
2405 }
2406
2407 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2408    R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
2409    that contains the relocation field and DATA points to the start of
2410    INPUT_SECTION.  */
2411
2412 struct mips_hi16
2413 {
2414   struct mips_hi16 *next;
2415   bfd_byte *data;
2416   asection *input_section;
2417   arelent rel;
2418 };
2419
2420 /* FIXME: This should not be a static variable.  */
2421
2422 static struct mips_hi16 *mips_hi16_list;
2423
2424 /* A howto special_function for REL *HI16 relocations.  We can only
2425    calculate the correct value once we've seen the partnering
2426    *LO16 relocation, so just save the information for later.
2427
2428    The ABI requires that the *LO16 immediately follow the *HI16.
2429    However, as a GNU extension, we permit an arbitrary number of
2430    *HI16s to be associated with a single *LO16.  This significantly
2431    simplies the relocation handling in gcc.  */
2432
2433 bfd_reloc_status_type
2434 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2435                           asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2436                           asection *input_section, bfd *output_bfd,
2437                           char **error_message ATTRIBUTE_UNUSED)
2438 {
2439   struct mips_hi16 *n;
2440
2441   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2442     return bfd_reloc_outofrange;
2443
2444   n = bfd_malloc (sizeof *n);
2445   if (n == NULL)
2446     return bfd_reloc_outofrange;
2447
2448   n->next = mips_hi16_list;
2449   n->data = data;
2450   n->input_section = input_section;
2451   n->rel = *reloc_entry;
2452   mips_hi16_list = n;
2453
2454   if (output_bfd != NULL)
2455     reloc_entry->address += input_section->output_offset;
2456
2457   return bfd_reloc_ok;
2458 }
2459
2460 /* A howto special_function for REL R_MIPS*_GOT16 relocations.  This is just
2461    like any other 16-bit relocation when applied to global symbols, but is
2462    treated in the same as R_MIPS_HI16 when applied to local symbols.  */
2463
2464 bfd_reloc_status_type
2465 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2466                            void *data, asection *input_section,
2467                            bfd *output_bfd, char **error_message)
2468 {
2469   if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2470       || bfd_is_und_section (bfd_get_section (symbol))
2471       || bfd_is_com_section (bfd_get_section (symbol)))
2472     /* The relocation is against a global symbol.  */
2473     return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2474                                         input_section, output_bfd,
2475                                         error_message);
2476
2477   return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2478                                    input_section, output_bfd, error_message);
2479 }
2480
2481 /* A howto special_function for REL *LO16 relocations.  The *LO16 itself
2482    is a straightforward 16 bit inplace relocation, but we must deal with
2483    any partnering high-part relocations as well.  */
2484
2485 bfd_reloc_status_type
2486 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2487                           void *data, asection *input_section,
2488                           bfd *output_bfd, char **error_message)
2489 {
2490   bfd_vma vallo;
2491   bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2492
2493   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2494     return bfd_reloc_outofrange;
2495
2496   _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2497                                  location);
2498   vallo = bfd_get_32 (abfd, location);
2499   _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2500                                location);
2501
2502   while (mips_hi16_list != NULL)
2503     {
2504       bfd_reloc_status_type ret;
2505       struct mips_hi16 *hi;
2506
2507       hi = mips_hi16_list;
2508
2509       /* R_MIPS*_GOT16 relocations are something of a special case.  We
2510          want to install the addend in the same way as for a R_MIPS*_HI16
2511          relocation (with a rightshift of 16).  However, since GOT16
2512          relocations can also be used with global symbols, their howto
2513          has a rightshift of 0.  */
2514       if (hi->rel.howto->type == R_MIPS_GOT16)
2515         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2516       else if (hi->rel.howto->type == R_MIPS16_GOT16)
2517         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2518       else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2519         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2520
2521       /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
2522          carry or borrow will induce a change of +1 or -1 in the high part.  */
2523       hi->rel.addend += (vallo + 0x8000) & 0xffff;
2524
2525       ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2526                                          hi->input_section, output_bfd,
2527                                          error_message);
2528       if (ret != bfd_reloc_ok)
2529         return ret;
2530
2531       mips_hi16_list = hi->next;
2532       free (hi);
2533     }
2534
2535   return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2536                                       input_section, output_bfd,
2537                                       error_message);
2538 }
2539
2540 /* A generic howto special_function.  This calculates and installs the
2541    relocation itself, thus avoiding the oft-discussed problems in
2542    bfd_perform_relocation and bfd_install_relocation.  */
2543
2544 bfd_reloc_status_type
2545 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2546                              asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2547                              asection *input_section, bfd *output_bfd,
2548                              char **error_message ATTRIBUTE_UNUSED)
2549 {
2550   bfd_signed_vma val;
2551   bfd_reloc_status_type status;
2552   bfd_boolean relocatable;
2553
2554   relocatable = (output_bfd != NULL);
2555
2556   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2557     return bfd_reloc_outofrange;
2558
2559   /* Build up the field adjustment in VAL.  */
2560   val = 0;
2561   if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2562     {
2563       /* Either we're calculating the final field value or we have a
2564          relocation against a section symbol.  Add in the section's
2565          offset or address.  */
2566       val += symbol->section->output_section->vma;
2567       val += symbol->section->output_offset;
2568     }
2569
2570   if (!relocatable)
2571     {
2572       /* We're calculating the final field value.  Add in the symbol's value
2573          and, if pc-relative, subtract the address of the field itself.  */
2574       val += symbol->value;
2575       if (reloc_entry->howto->pc_relative)
2576         {
2577           val -= input_section->output_section->vma;
2578           val -= input_section->output_offset;
2579           val -= reloc_entry->address;
2580         }
2581     }
2582
2583   /* VAL is now the final adjustment.  If we're keeping this relocation
2584      in the output file, and if the relocation uses a separate addend,
2585      we just need to add VAL to that addend.  Otherwise we need to add
2586      VAL to the relocation field itself.  */
2587   if (relocatable && !reloc_entry->howto->partial_inplace)
2588     reloc_entry->addend += val;
2589   else
2590     {
2591       bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2592
2593       /* Add in the separate addend, if any.  */
2594       val += reloc_entry->addend;
2595
2596       /* Add VAL to the relocation field.  */
2597       _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2598                                      location);
2599       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2600                                        location);
2601       _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2602                                    location);
2603
2604       if (status != bfd_reloc_ok)
2605         return status;
2606     }
2607
2608   if (relocatable)
2609     reloc_entry->address += input_section->output_offset;
2610
2611   return bfd_reloc_ok;
2612 }
2613 \f
2614 /* Swap an entry in a .gptab section.  Note that these routines rely
2615    on the equivalence of the two elements of the union.  */
2616
2617 static void
2618 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2619                               Elf32_gptab *in)
2620 {
2621   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2622   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2623 }
2624
2625 static void
2626 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2627                                Elf32_External_gptab *ex)
2628 {
2629   H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2630   H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2631 }
2632
2633 static void
2634 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2635                                 Elf32_External_compact_rel *ex)
2636 {
2637   H_PUT_32 (abfd, in->id1, ex->id1);
2638   H_PUT_32 (abfd, in->num, ex->num);
2639   H_PUT_32 (abfd, in->id2, ex->id2);
2640   H_PUT_32 (abfd, in->offset, ex->offset);
2641   H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2642   H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2643 }
2644
2645 static void
2646 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2647                            Elf32_External_crinfo *ex)
2648 {
2649   unsigned long l;
2650
2651   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2652        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2653        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2654        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2655   H_PUT_32 (abfd, l, ex->info);
2656   H_PUT_32 (abfd, in->konst, ex->konst);
2657   H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2658 }
2659 \f
2660 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
2661    routines swap this structure in and out.  They are used outside of
2662    BFD, so they are globally visible.  */
2663
2664 void
2665 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2666                                 Elf32_RegInfo *in)
2667 {
2668   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2669   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2670   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2671   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2672   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2673   in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2674 }
2675
2676 void
2677 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2678                                  Elf32_External_RegInfo *ex)
2679 {
2680   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2681   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2682   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2683   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2684   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2685   H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2686 }
2687
2688 /* In the 64 bit ABI, the .MIPS.options section holds register
2689    information in an Elf64_Reginfo structure.  These routines swap
2690    them in and out.  They are globally visible because they are used
2691    outside of BFD.  These routines are here so that gas can call them
2692    without worrying about whether the 64 bit ABI has been included.  */
2693
2694 void
2695 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2696                                 Elf64_Internal_RegInfo *in)
2697 {
2698   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2699   in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2700   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2701   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2702   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2703   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2704   in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2705 }
2706
2707 void
2708 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2709                                  Elf64_External_RegInfo *ex)
2710 {
2711   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2712   H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2713   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2714   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2715   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2716   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2717   H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2718 }
2719
2720 /* Swap in an options header.  */
2721
2722 void
2723 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2724                               Elf_Internal_Options *in)
2725 {
2726   in->kind = H_GET_8 (abfd, ex->kind);
2727   in->size = H_GET_8 (abfd, ex->size);
2728   in->section = H_GET_16 (abfd, ex->section);
2729   in->info = H_GET_32 (abfd, ex->info);
2730 }
2731
2732 /* Swap out an options header.  */
2733
2734 void
2735 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2736                                Elf_External_Options *ex)
2737 {
2738   H_PUT_8 (abfd, in->kind, ex->kind);
2739   H_PUT_8 (abfd, in->size, ex->size);
2740   H_PUT_16 (abfd, in->section, ex->section);
2741   H_PUT_32 (abfd, in->info, ex->info);
2742 }
2743
2744 /* Swap in an abiflags structure.  */
2745
2746 void
2747 bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd,
2748                                   const Elf_External_ABIFlags_v0 *ex,
2749                                   Elf_Internal_ABIFlags_v0 *in)
2750 {
2751   in->version = H_GET_16 (abfd, ex->version);
2752   in->isa_level = H_GET_8 (abfd, ex->isa_level);
2753   in->isa_rev = H_GET_8 (abfd, ex->isa_rev);
2754   in->gpr_size = H_GET_8 (abfd, ex->gpr_size);
2755   in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size);
2756   in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size);
2757   in->fp_abi = H_GET_8 (abfd, ex->fp_abi);
2758   in->isa_ext = H_GET_32 (abfd, ex->isa_ext);
2759   in->ases = H_GET_32 (abfd, ex->ases);
2760   in->flags1 = H_GET_32 (abfd, ex->flags1);
2761   in->flags2 = H_GET_32 (abfd, ex->flags2);
2762 }
2763
2764 /* Swap out an abiflags structure.  */
2765
2766 void
2767 bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd,
2768                                    const Elf_Internal_ABIFlags_v0 *in,
2769                                    Elf_External_ABIFlags_v0 *ex)
2770 {
2771   H_PUT_16 (abfd, in->version, ex->version);
2772   H_PUT_8 (abfd, in->isa_level, ex->isa_level);
2773   H_PUT_8 (abfd, in->isa_rev, ex->isa_rev);
2774   H_PUT_8 (abfd, in->gpr_size, ex->gpr_size);
2775   H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size);
2776   H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size);
2777   H_PUT_8 (abfd, in->fp_abi, ex->fp_abi);
2778   H_PUT_32 (abfd, in->isa_ext, ex->isa_ext);
2779   H_PUT_32 (abfd, in->ases, ex->ases);
2780   H_PUT_32 (abfd, in->flags1, ex->flags1);
2781   H_PUT_32 (abfd, in->flags2, ex->flags2);
2782 }
2783 \f
2784 /* This function is called via qsort() to sort the dynamic relocation
2785    entries by increasing r_symndx value.  */
2786
2787 static int
2788 sort_dynamic_relocs (const void *arg1, const void *arg2)
2789 {
2790   Elf_Internal_Rela int_reloc1;
2791   Elf_Internal_Rela int_reloc2;
2792   int diff;
2793
2794   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2795   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2796
2797   diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2798   if (diff != 0)
2799     return diff;
2800
2801   if (int_reloc1.r_offset < int_reloc2.r_offset)
2802     return -1;
2803   if (int_reloc1.r_offset > int_reloc2.r_offset)
2804     return 1;
2805   return 0;
2806 }
2807
2808 /* Like sort_dynamic_relocs, but used for elf64 relocations.  */
2809
2810 static int
2811 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2812                         const void *arg2 ATTRIBUTE_UNUSED)
2813 {
2814 #ifdef BFD64
2815   Elf_Internal_Rela int_reloc1[3];
2816   Elf_Internal_Rela int_reloc2[3];
2817
2818   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2819     (reldyn_sorting_bfd, arg1, int_reloc1);
2820   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2821     (reldyn_sorting_bfd, arg2, int_reloc2);
2822
2823   if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2824     return -1;
2825   if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2826     return 1;
2827
2828   if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2829     return -1;
2830   if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2831     return 1;
2832   return 0;
2833 #else
2834   abort ();
2835 #endif
2836 }
2837
2838
2839 /* This routine is used to write out ECOFF debugging external symbol
2840    information.  It is called via mips_elf_link_hash_traverse.  The
2841    ECOFF external symbol information must match the ELF external
2842    symbol information.  Unfortunately, at this point we don't know
2843    whether a symbol is required by reloc information, so the two
2844    tables may wind up being different.  We must sort out the external
2845    symbol information before we can set the final size of the .mdebug
2846    section, and we must set the size of the .mdebug section before we
2847    can relocate any sections, and we can't know which symbols are
2848    required by relocation until we relocate the sections.
2849    Fortunately, it is relatively unlikely that any symbol will be
2850    stripped but required by a reloc.  In particular, it can not happen
2851    when generating a final executable.  */
2852
2853 static bfd_boolean
2854 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2855 {
2856   struct extsym_info *einfo = data;
2857   bfd_boolean strip;
2858   asection *sec, *output_section;
2859
2860   if (h->root.indx == -2)
2861     strip = FALSE;
2862   else if ((h->root.def_dynamic
2863             || h->root.ref_dynamic
2864             || h->root.type == bfd_link_hash_new)
2865            && !h->root.def_regular
2866            && !h->root.ref_regular)
2867     strip = TRUE;
2868   else if (einfo->info->strip == strip_all
2869            || (einfo->info->strip == strip_some
2870                && bfd_hash_lookup (einfo->info->keep_hash,
2871                                    h->root.root.root.string,
2872                                    FALSE, FALSE) == NULL))
2873     strip = TRUE;
2874   else
2875     strip = FALSE;
2876
2877   if (strip)
2878     return TRUE;
2879
2880   if (h->esym.ifd == -2)
2881     {
2882       h->esym.jmptbl = 0;
2883       h->esym.cobol_main = 0;
2884       h->esym.weakext = 0;
2885       h->esym.reserved = 0;
2886       h->esym.ifd = ifdNil;
2887       h->esym.asym.value = 0;
2888       h->esym.asym.st = stGlobal;
2889
2890       if (h->root.root.type == bfd_link_hash_undefined
2891           || h->root.root.type == bfd_link_hash_undefweak)
2892         {
2893           const char *name;
2894
2895           /* Use undefined class.  Also, set class and type for some
2896              special symbols.  */
2897           name = h->root.root.root.string;
2898           if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2899               || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2900             {
2901               h->esym.asym.sc = scData;
2902               h->esym.asym.st = stLabel;
2903               h->esym.asym.value = 0;
2904             }
2905           else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2906             {
2907               h->esym.asym.sc = scAbs;
2908               h->esym.asym.st = stLabel;
2909               h->esym.asym.value =
2910                 mips_elf_hash_table (einfo->info)->procedure_count;
2911             }
2912           else
2913             h->esym.asym.sc = scUndefined;
2914         }
2915       else if (h->root.root.type != bfd_link_hash_defined
2916           && h->root.root.type != bfd_link_hash_defweak)
2917         h->esym.asym.sc = scAbs;
2918       else
2919         {
2920           const char *name;
2921
2922           sec = h->root.root.u.def.section;
2923           output_section = sec->output_section;
2924
2925           /* When making a shared library and symbol h is the one from
2926              the another shared library, OUTPUT_SECTION may be null.  */
2927           if (output_section == NULL)
2928             h->esym.asym.sc = scUndefined;
2929           else
2930             {
2931               name = bfd_section_name (output_section->owner, output_section);
2932
2933               if (strcmp (name, ".text") == 0)
2934                 h->esym.asym.sc = scText;
2935               else if (strcmp (name, ".data") == 0)
2936                 h->esym.asym.sc = scData;
2937               else if (strcmp (name, ".sdata") == 0)
2938                 h->esym.asym.sc = scSData;
2939               else if (strcmp (name, ".rodata") == 0
2940                        || strcmp (name, ".rdata") == 0)
2941                 h->esym.asym.sc = scRData;
2942               else if (strcmp (name, ".bss") == 0)
2943                 h->esym.asym.sc = scBss;
2944               else if (strcmp (name, ".sbss") == 0)
2945                 h->esym.asym.sc = scSBss;
2946               else if (strcmp (name, ".init") == 0)
2947                 h->esym.asym.sc = scInit;
2948               else if (strcmp (name, ".fini") == 0)
2949                 h->esym.asym.sc = scFini;
2950               else
2951                 h->esym.asym.sc = scAbs;
2952             }
2953         }
2954
2955       h->esym.asym.reserved = 0;
2956       h->esym.asym.index = indexNil;
2957     }
2958
2959   if (h->root.root.type == bfd_link_hash_common)
2960     h->esym.asym.value = h->root.root.u.c.size;
2961   else if (h->root.root.type == bfd_link_hash_defined
2962            || h->root.root.type == bfd_link_hash_defweak)
2963     {
2964       if (h->esym.asym.sc == scCommon)
2965         h->esym.asym.sc = scBss;
2966       else if (h->esym.asym.sc == scSCommon)
2967         h->esym.asym.sc = scSBss;
2968
2969       sec = h->root.root.u.def.section;
2970       output_section = sec->output_section;
2971       if (output_section != NULL)
2972         h->esym.asym.value = (h->root.root.u.def.value
2973                               + sec->output_offset
2974                               + output_section->vma);
2975       else
2976         h->esym.asym.value = 0;
2977     }
2978   else
2979     {
2980       struct mips_elf_link_hash_entry *hd = h;
2981
2982       while (hd->root.root.type == bfd_link_hash_indirect)
2983         hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2984
2985       if (hd->needs_lazy_stub)
2986         {
2987           BFD_ASSERT (hd->root.plt.plist != NULL);
2988           BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE);
2989           /* Set type and value for a symbol with a function stub.  */
2990           h->esym.asym.st = stProc;
2991           sec = hd->root.root.u.def.section;
2992           if (sec == NULL)
2993             h->esym.asym.value = 0;
2994           else
2995             {
2996               output_section = sec->output_section;
2997               if (output_section != NULL)
2998                 h->esym.asym.value = (hd->root.plt.plist->stub_offset
2999                                       + sec->output_offset
3000                                       + output_section->vma);
3001               else
3002                 h->esym.asym.value = 0;
3003             }
3004         }
3005     }
3006
3007   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
3008                                       h->root.root.root.string,
3009                                       &h->esym))
3010     {
3011       einfo->failed = TRUE;
3012       return FALSE;
3013     }
3014
3015   return TRUE;
3016 }
3017
3018 /* A comparison routine used to sort .gptab entries.  */
3019
3020 static int
3021 gptab_compare (const void *p1, const void *p2)
3022 {
3023   const Elf32_gptab *a1 = p1;
3024   const Elf32_gptab *a2 = p2;
3025
3026   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
3027 }
3028 \f
3029 /* Functions to manage the got entry hash table.  */
3030
3031 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
3032    hash number.  */
3033
3034 static INLINE hashval_t
3035 mips_elf_hash_bfd_vma (bfd_vma addr)
3036 {
3037 #ifdef BFD64
3038   return addr + (addr >> 32);
3039 #else
3040   return addr;
3041 #endif
3042 }
3043
3044 static hashval_t
3045 mips_elf_got_entry_hash (const void *entry_)
3046 {
3047   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
3048
3049   return (entry->symndx
3050           + ((entry->tls_type == GOT_TLS_LDM) << 18)
3051           + (entry->tls_type == GOT_TLS_LDM ? 0
3052              : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
3053              : entry->symndx >= 0 ? (entry->abfd->id
3054                                      + mips_elf_hash_bfd_vma (entry->d.addend))
3055              : entry->d.h->root.root.root.hash));
3056 }
3057
3058 static int
3059 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
3060 {
3061   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
3062   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
3063
3064   return (e1->symndx == e2->symndx
3065           && e1->tls_type == e2->tls_type
3066           && (e1->tls_type == GOT_TLS_LDM ? TRUE
3067               : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address
3068               : e1->symndx >= 0 ? (e1->abfd == e2->abfd
3069                                    && e1->d.addend == e2->d.addend)
3070               : e2->abfd && e1->d.h == e2->d.h));
3071 }
3072
3073 static hashval_t
3074 mips_got_page_ref_hash (const void *ref_)
3075 {
3076   const struct mips_got_page_ref *ref;
3077
3078   ref = (const struct mips_got_page_ref *) ref_;
3079   return ((ref->symndx >= 0
3080            ? (hashval_t) (ref->u.abfd->id + ref->symndx)
3081            : ref->u.h->root.root.root.hash)
3082           + mips_elf_hash_bfd_vma (ref->addend));
3083 }
3084
3085 static int
3086 mips_got_page_ref_eq (const void *ref1_, const void *ref2_)
3087 {
3088   const struct mips_got_page_ref *ref1, *ref2;
3089
3090   ref1 = (const struct mips_got_page_ref *) ref1_;
3091   ref2 = (const struct mips_got_page_ref *) ref2_;
3092   return (ref1->symndx == ref2->symndx
3093           && (ref1->symndx < 0
3094               ? ref1->u.h == ref2->u.h
3095               : ref1->u.abfd == ref2->u.abfd)
3096           && ref1->addend == ref2->addend);
3097 }
3098
3099 static hashval_t
3100 mips_got_page_entry_hash (const void *entry_)
3101 {
3102   const struct mips_got_page_entry *entry;
3103
3104   entry = (const struct mips_got_page_entry *) entry_;
3105   return entry->sec->id;
3106 }
3107
3108 static int
3109 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
3110 {
3111   const struct mips_got_page_entry *entry1, *entry2;
3112
3113   entry1 = (const struct mips_got_page_entry *) entry1_;
3114   entry2 = (const struct mips_got_page_entry *) entry2_;
3115   return entry1->sec == entry2->sec;
3116 }
3117 \f
3118 /* Create and return a new mips_got_info structure.  */
3119
3120 static struct mips_got_info *
3121 mips_elf_create_got_info (bfd *abfd)
3122 {
3123   struct mips_got_info *g;
3124
3125   g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
3126   if (g == NULL)
3127     return NULL;
3128
3129   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
3130                                     mips_elf_got_entry_eq, NULL);
3131   if (g->got_entries == NULL)
3132     return NULL;
3133
3134   g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash,
3135                                       mips_got_page_ref_eq, NULL);
3136   if (g->got_page_refs == NULL)
3137     return NULL;
3138
3139   return g;
3140 }
3141
3142 /* Return the GOT info for input bfd ABFD, trying to create a new one if
3143    CREATE_P and if ABFD doesn't already have a GOT.  */
3144
3145 static struct mips_got_info *
3146 mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p)
3147 {
3148   struct mips_elf_obj_tdata *tdata;
3149
3150   if (!is_mips_elf (abfd))
3151     return NULL;
3152
3153   tdata = mips_elf_tdata (abfd);
3154   if (!tdata->got && create_p)
3155     tdata->got = mips_elf_create_got_info (abfd);
3156   return tdata->got;
3157 }
3158
3159 /* Record that ABFD should use output GOT G.  */
3160
3161 static void
3162 mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g)
3163 {
3164   struct mips_elf_obj_tdata *tdata;
3165
3166   BFD_ASSERT (is_mips_elf (abfd));
3167   tdata = mips_elf_tdata (abfd);
3168   if (tdata->got)
3169     {
3170       /* The GOT structure itself and the hash table entries are
3171          allocated to a bfd, but the hash tables aren't.  */
3172       htab_delete (tdata->got->got_entries);
3173       htab_delete (tdata->got->got_page_refs);
3174       if (tdata->got->got_page_entries)
3175         htab_delete (tdata->got->got_page_entries);
3176     }
3177   tdata->got = g;
3178 }
3179
3180 /* Return the dynamic relocation section.  If it doesn't exist, try to
3181    create a new it if CREATE_P, otherwise return NULL.  Also return NULL
3182    if creation fails.  */
3183
3184 static asection *
3185 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
3186 {
3187   const char *dname;
3188   asection *sreloc;
3189   bfd *dynobj;
3190
3191   dname = MIPS_ELF_REL_DYN_NAME (info);
3192   dynobj = elf_hash_table (info)->dynobj;
3193   sreloc = bfd_get_linker_section (dynobj, dname);
3194   if (sreloc == NULL && create_p)
3195     {
3196       sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
3197                                                    (SEC_ALLOC
3198                                                     | SEC_LOAD
3199                                                     | SEC_HAS_CONTENTS
3200                                                     | SEC_IN_MEMORY
3201                                                     | SEC_LINKER_CREATED
3202                                                     | SEC_READONLY));
3203       if (sreloc == NULL
3204           || ! bfd_set_section_alignment (dynobj, sreloc,
3205                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
3206         return NULL;
3207     }
3208   return sreloc;
3209 }
3210
3211 /* Return the GOT_TLS_* type required by relocation type R_TYPE.  */
3212
3213 static int
3214 mips_elf_reloc_tls_type (unsigned int r_type)
3215 {
3216   if (tls_gd_reloc_p (r_type))
3217     return GOT_TLS_GD;
3218
3219   if (tls_ldm_reloc_p (r_type))
3220     return GOT_TLS_LDM;
3221
3222   if (tls_gottprel_reloc_p (r_type))
3223     return GOT_TLS_IE;
3224
3225   return GOT_TLS_NONE;
3226 }
3227
3228 /* Return the number of GOT slots needed for GOT TLS type TYPE.  */
3229
3230 static int
3231 mips_tls_got_entries (unsigned int type)
3232 {
3233   switch (type)
3234     {
3235     case GOT_TLS_GD:
3236     case GOT_TLS_LDM:
3237       return 2;
3238
3239     case GOT_TLS_IE:
3240       return 1;
3241
3242     case GOT_TLS_NONE:
3243       return 0;
3244     }
3245   abort ();
3246 }
3247
3248 /* Count the number of relocations needed for a TLS GOT entry, with
3249    access types from TLS_TYPE, and symbol H (or a local symbol if H
3250    is NULL).  */
3251
3252 static int
3253 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
3254                      struct elf_link_hash_entry *h)
3255 {
3256   int indx = 0;
3257   bfd_boolean need_relocs = FALSE;
3258   bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3259
3260   if (h != NULL
3261       && h->dynindx != -1
3262       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
3263       && (bfd_link_dll (info) || !SYMBOL_REFERENCES_LOCAL (info, h)))
3264     indx = h->dynindx;
3265
3266   if ((bfd_link_dll (info) || indx != 0)
3267       && (h == NULL
3268           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3269           || h->root.type != bfd_link_hash_undefweak))
3270     need_relocs = TRUE;
3271
3272   if (!need_relocs)
3273     return 0;
3274
3275   switch (tls_type)
3276     {
3277     case GOT_TLS_GD:
3278       return indx != 0 ? 2 : 1;
3279
3280     case GOT_TLS_IE:
3281       return 1;
3282
3283     case GOT_TLS_LDM:
3284       return bfd_link_dll (info) ? 1 : 0;
3285
3286     default:
3287       return 0;
3288     }
3289 }
3290
3291 /* Add the number of GOT entries and TLS relocations required by ENTRY
3292    to G.  */
3293
3294 static void
3295 mips_elf_count_got_entry (struct bfd_link_info *info,
3296                           struct mips_got_info *g,
3297                           struct mips_got_entry *entry)
3298 {
3299   if (entry->tls_type)
3300     {
3301       g->tls_gotno += mips_tls_got_entries (entry->tls_type);
3302       g->relocs += mips_tls_got_relocs (info, entry->tls_type,
3303                                         entry->symndx < 0
3304                                         ? &entry->d.h->root : NULL);
3305     }
3306   else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
3307     g->local_gotno += 1;
3308   else
3309     g->global_gotno += 1;
3310 }
3311
3312 /* Output a simple dynamic relocation into SRELOC.  */
3313
3314 static void
3315 mips_elf_output_dynamic_relocation (bfd *output_bfd,
3316                                     asection *sreloc,
3317                                     unsigned long reloc_index,
3318                                     unsigned long indx,
3319                                     int r_type,
3320                                     bfd_vma offset)
3321 {
3322   Elf_Internal_Rela rel[3];
3323
3324   memset (rel, 0, sizeof (rel));
3325
3326   rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3327   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3328
3329   if (ABI_64_P (output_bfd))
3330     {
3331       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3332         (output_bfd, &rel[0],
3333          (sreloc->contents
3334           + reloc_index * sizeof (Elf64_Mips_External_Rel)));
3335     }
3336   else
3337     bfd_elf32_swap_reloc_out
3338       (output_bfd, &rel[0],
3339        (sreloc->contents
3340         + reloc_index * sizeof (Elf32_External_Rel)));
3341 }
3342
3343 /* Initialize a set of TLS GOT entries for one symbol.  */
3344
3345 static void
3346 mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info,
3347                                struct mips_got_entry *entry,
3348                                struct mips_elf_link_hash_entry *h,
3349                                bfd_vma value)
3350 {
3351   bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3352   struct mips_elf_link_hash_table *htab;
3353   int indx;
3354   asection *sreloc, *sgot;
3355   bfd_vma got_offset, got_offset2;
3356   bfd_boolean need_relocs = FALSE;
3357
3358   htab = mips_elf_hash_table (info);
3359   if (htab == NULL)
3360     return;
3361
3362   sgot = htab->root.sgot;
3363
3364   indx = 0;
3365   if (h != NULL
3366       && h->root.dynindx != -1
3367       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), &h->root)
3368       && (bfd_link_dll (info) || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3369     indx = h->root.dynindx;
3370
3371   if (entry->tls_initialized)
3372     return;
3373
3374   if ((bfd_link_dll (info) || indx != 0)
3375       && (h == NULL
3376           || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3377           || h->root.type != bfd_link_hash_undefweak))
3378     need_relocs = TRUE;
3379
3380   /* MINUS_ONE means the symbol is not defined in this object.  It may not
3381      be defined at all; assume that the value doesn't matter in that
3382      case.  Otherwise complain if we would use the value.  */
3383   BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3384               || h->root.root.type == bfd_link_hash_undefweak);
3385
3386   /* Emit necessary relocations.  */
3387   sreloc = mips_elf_rel_dyn_section (info, FALSE);
3388   got_offset = entry->gotidx;
3389
3390   switch (entry->tls_type)
3391     {
3392     case GOT_TLS_GD:
3393       /* General Dynamic.  */
3394       got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd);
3395
3396       if (need_relocs)
3397         {
3398           mips_elf_output_dynamic_relocation
3399             (abfd, sreloc, sreloc->reloc_count++, indx,
3400              ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3401              sgot->output_offset + sgot->output_section->vma + got_offset);
3402
3403           if (indx)
3404             mips_elf_output_dynamic_relocation
3405               (abfd, sreloc, sreloc->reloc_count++, indx,
3406                ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3407                sgot->output_offset + sgot->output_section->vma + got_offset2);
3408           else
3409             MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3410                                sgot->contents + got_offset2);
3411         }
3412       else
3413         {
3414           MIPS_ELF_PUT_WORD (abfd, 1,
3415                              sgot->contents + got_offset);
3416           MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3417                              sgot->contents + got_offset2);
3418         }
3419       break;
3420
3421     case GOT_TLS_IE:
3422       /* Initial Exec model.  */
3423       if (need_relocs)
3424         {
3425           if (indx == 0)
3426             MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3427                                sgot->contents + got_offset);
3428           else
3429             MIPS_ELF_PUT_WORD (abfd, 0,
3430                                sgot->contents + got_offset);
3431
3432           mips_elf_output_dynamic_relocation
3433             (abfd, sreloc, sreloc->reloc_count++, indx,
3434              ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3435              sgot->output_offset + sgot->output_section->vma + got_offset);
3436         }
3437       else
3438         MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3439                            sgot->contents + got_offset);
3440       break;
3441
3442     case GOT_TLS_LDM:
3443       /* The initial offset is zero, and the LD offsets will include the
3444          bias by DTP_OFFSET.  */
3445       MIPS_ELF_PUT_WORD (abfd, 0,
3446                          sgot->contents + got_offset
3447                          + MIPS_ELF_GOT_SIZE (abfd));
3448
3449       if (!bfd_link_dll (info))
3450         MIPS_ELF_PUT_WORD (abfd, 1,
3451                            sgot->contents + got_offset);
3452       else
3453         mips_elf_output_dynamic_relocation
3454           (abfd, sreloc, sreloc->reloc_count++, indx,
3455            ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3456            sgot->output_offset + sgot->output_section->vma + got_offset);
3457       break;
3458
3459     default:
3460       abort ();
3461     }
3462
3463   entry->tls_initialized = TRUE;
3464 }
3465
3466 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3467    for global symbol H.  .got.plt comes before the GOT, so the offset
3468    will be negative.  */
3469
3470 static bfd_vma
3471 mips_elf_gotplt_index (struct bfd_link_info *info,
3472                        struct elf_link_hash_entry *h)
3473 {
3474   bfd_vma got_address, got_value;
3475   struct mips_elf_link_hash_table *htab;
3476
3477   htab = mips_elf_hash_table (info);
3478   BFD_ASSERT (htab != NULL);
3479
3480   BFD_ASSERT (h->plt.plist != NULL);
3481   BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE);
3482
3483   /* Calculate the address of the associated .got.plt entry.  */
3484   got_address = (htab->root.sgotplt->output_section->vma
3485                  + htab->root.sgotplt->output_offset
3486                  + (h->plt.plist->gotplt_index
3487                     * MIPS_ELF_GOT_SIZE (info->output_bfd)));
3488
3489   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
3490   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3491                + htab->root.hgot->root.u.def.section->output_offset
3492                + htab->root.hgot->root.u.def.value);
3493
3494   return got_address - got_value;
3495 }
3496
3497 /* Return the GOT offset for address VALUE.   If there is not yet a GOT
3498    entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
3499    create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
3500    offset can be found.  */
3501
3502 static bfd_vma
3503 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3504                           bfd_vma value, unsigned long r_symndx,
3505                           struct mips_elf_link_hash_entry *h, int r_type)
3506 {
3507   struct mips_elf_link_hash_table *htab;
3508   struct mips_got_entry *entry;
3509
3510   htab = mips_elf_hash_table (info);
3511   BFD_ASSERT (htab != NULL);
3512
3513   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3514                                            r_symndx, h, r_type);
3515   if (!entry)
3516     return MINUS_ONE;
3517
3518   if (entry->tls_type)
3519     mips_elf_initialize_tls_slots (abfd, info, entry, h, value);
3520   return entry->gotidx;
3521 }
3522
3523 /* Return the GOT index of global symbol H in the primary GOT.  */
3524
3525 static bfd_vma
3526 mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info,
3527                                    struct elf_link_hash_entry *h)
3528 {
3529   struct mips_elf_link_hash_table *htab;
3530   long global_got_dynindx;
3531   struct mips_got_info *g;
3532   bfd_vma got_index;
3533
3534   htab = mips_elf_hash_table (info);
3535   BFD_ASSERT (htab != NULL);
3536
3537   global_got_dynindx = 0;
3538   if (htab->global_gotsym != NULL)
3539     global_got_dynindx = htab->global_gotsym->dynindx;
3540
3541   /* Once we determine the global GOT entry with the lowest dynamic
3542      symbol table index, we must put all dynamic symbols with greater
3543      indices into the primary GOT.  That makes it easy to calculate the
3544      GOT offset.  */
3545   BFD_ASSERT (h->dynindx >= global_got_dynindx);
3546   g = mips_elf_bfd_got (obfd, FALSE);
3547   got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3548                * MIPS_ELF_GOT_SIZE (obfd));
3549   BFD_ASSERT (got_index < htab->root.sgot->size);
3550
3551   return got_index;
3552 }
3553
3554 /* Return the GOT index for the global symbol indicated by H, which is
3555    referenced by a relocation of type R_TYPE in IBFD.  */
3556
3557 static bfd_vma
3558 mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd,
3559                            struct elf_link_hash_entry *h, int r_type)
3560 {
3561   struct mips_elf_link_hash_table *htab;
3562   struct mips_got_info *g;
3563   struct mips_got_entry lookup, *entry;
3564   bfd_vma gotidx;
3565
3566   htab = mips_elf_hash_table (info);
3567   BFD_ASSERT (htab != NULL);
3568
3569   g = mips_elf_bfd_got (ibfd, FALSE);
3570   BFD_ASSERT (g);
3571
3572   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3573   if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE))
3574     return mips_elf_primary_global_got_index (obfd, info, h);
3575
3576   lookup.abfd = ibfd;
3577   lookup.symndx = -1;
3578   lookup.d.h = (struct mips_elf_link_hash_entry *) h;
3579   entry = htab_find (g->got_entries, &lookup);
3580   BFD_ASSERT (entry);
3581
3582   gotidx = entry->gotidx;
3583   BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3584
3585   if (lookup.tls_type)
3586     {
3587       bfd_vma value = MINUS_ONE;
3588
3589       if ((h->root.type == bfd_link_hash_defined
3590            || h->root.type == bfd_link_hash_defweak)
3591           && h->root.u.def.section->output_section)
3592         value = (h->root.u.def.value
3593                  + h->root.u.def.section->output_offset
3594                  + h->root.u.def.section->output_section->vma);
3595
3596       mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value);
3597     }
3598   return gotidx;
3599 }
3600
3601 /* Find a GOT page entry that points to within 32KB of VALUE.  These
3602    entries are supposed to be placed at small offsets in the GOT, i.e.,
3603    within 32KB of GP.  Return the index of the GOT entry, or -1 if no
3604    entry could be created.  If OFFSETP is nonnull, use it to return the
3605    offset of the GOT entry from VALUE.  */
3606
3607 static bfd_vma
3608 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3609                    bfd_vma value, bfd_vma *offsetp)
3610 {
3611   bfd_vma page, got_index;
3612   struct mips_got_entry *entry;
3613
3614   page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3615   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3616                                            NULL, R_MIPS_GOT_PAGE);
3617
3618   if (!entry)
3619     return MINUS_ONE;
3620
3621   got_index = entry->gotidx;
3622
3623   if (offsetp)
3624     *offsetp = value - entry->d.address;
3625
3626   return got_index;
3627 }
3628
3629 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3630    EXTERNAL is true if the relocation was originally against a global
3631    symbol that binds locally.  */
3632
3633 static bfd_vma
3634 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3635                       bfd_vma value, bfd_boolean external)
3636 {
3637   struct mips_got_entry *entry;
3638
3639   /* GOT16 relocations against local symbols are followed by a LO16
3640      relocation; those against global symbols are not.  Thus if the
3641      symbol was originally local, the GOT16 relocation should load the
3642      equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
3643   if (! external)
3644     value = mips_elf_high (value) << 16;
3645
3646   /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3647      R_MIPS16_GOT16, R_MIPS_CALL16, etc.  The format of the entry is the
3648      same in all cases.  */
3649   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3650                                            NULL, R_MIPS_GOT16);
3651   if (entry)
3652     return entry->gotidx;
3653   else
3654     return MINUS_ONE;
3655 }
3656
3657 /* Returns the offset for the entry at the INDEXth position
3658    in the GOT.  */
3659
3660 static bfd_vma
3661 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3662                                 bfd *input_bfd, bfd_vma got_index)
3663 {
3664   struct mips_elf_link_hash_table *htab;
3665   asection *sgot;
3666   bfd_vma gp;
3667
3668   htab = mips_elf_hash_table (info);
3669   BFD_ASSERT (htab != NULL);
3670
3671   sgot = htab->root.sgot;
3672   gp = _bfd_get_gp_value (output_bfd)
3673     + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3674
3675   return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3676 }
3677
3678 /* Create and return a local GOT entry for VALUE, which was calculated
3679    from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
3680    be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
3681    instead.  */
3682
3683 static struct mips_got_entry *
3684 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3685                                  bfd *ibfd, bfd_vma value,
3686                                  unsigned long r_symndx,
3687                                  struct mips_elf_link_hash_entry *h,
3688                                  int r_type)
3689 {
3690   struct mips_got_entry lookup, *entry;
3691   void **loc;
3692   struct mips_got_info *g;
3693   struct mips_elf_link_hash_table *htab;
3694   bfd_vma gotidx;
3695
3696   htab = mips_elf_hash_table (info);
3697   BFD_ASSERT (htab != NULL);
3698
3699   g = mips_elf_bfd_got (ibfd, FALSE);
3700   if (g == NULL)
3701     {
3702       g = mips_elf_bfd_got (abfd, FALSE);
3703       BFD_ASSERT (g != NULL);
3704     }
3705
3706   /* This function shouldn't be called for symbols that live in the global
3707      area of the GOT.  */
3708   BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3709
3710   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3711   if (lookup.tls_type)
3712     {
3713       lookup.abfd = ibfd;
3714       if (tls_ldm_reloc_p (r_type))
3715         {
3716           lookup.symndx = 0;
3717           lookup.d.addend = 0;
3718         }
3719       else if (h == NULL)
3720         {
3721           lookup.symndx = r_symndx;
3722           lookup.d.addend = 0;
3723         }
3724       else
3725         {
3726           lookup.symndx = -1;
3727           lookup.d.h = h;
3728         }
3729
3730       entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup);
3731       BFD_ASSERT (entry);
3732
3733       gotidx = entry->gotidx;
3734       BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3735
3736       return entry;
3737     }
3738
3739   lookup.abfd = NULL;
3740   lookup.symndx = -1;
3741   lookup.d.address = value;
3742   loc = htab_find_slot (g->got_entries, &lookup, INSERT);
3743   if (!loc)
3744     return NULL;
3745
3746   entry = (struct mips_got_entry *) *loc;
3747   if (entry)
3748     return entry;
3749
3750   if (g->assigned_low_gotno > g->assigned_high_gotno)
3751     {
3752       /* We didn't allocate enough space in the GOT.  */
3753       _bfd_error_handler
3754         (_("not enough GOT space for local GOT entries"));
3755       bfd_set_error (bfd_error_bad_value);
3756       return NULL;
3757     }
3758
3759   entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3760   if (!entry)
3761     return NULL;
3762
3763   if (got16_reloc_p (r_type)
3764       || call16_reloc_p (r_type)
3765       || got_page_reloc_p (r_type)
3766       || got_disp_reloc_p (r_type))
3767     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++;
3768   else
3769     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--;
3770
3771   *entry = lookup;
3772   *loc = entry;
3773
3774   MIPS_ELF_PUT_WORD (abfd, value, htab->root.sgot->contents + entry->gotidx);
3775
3776   /* These GOT entries need a dynamic relocation on VxWorks.  */
3777   if (htab->is_vxworks)
3778     {
3779       Elf_Internal_Rela outrel;
3780       asection *s;
3781       bfd_byte *rloc;
3782       bfd_vma got_address;
3783
3784       s = mips_elf_rel_dyn_section (info, FALSE);
3785       got_address = (htab->root.sgot->output_section->vma
3786                      + htab->root.sgot->output_offset
3787                      + entry->gotidx);
3788
3789       rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3790       outrel.r_offset = got_address;
3791       outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3792       outrel.r_addend = value;
3793       bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3794     }
3795
3796   return entry;
3797 }
3798
3799 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3800    The number might be exact or a worst-case estimate, depending on how
3801    much information is available to elf_backend_omit_section_dynsym at
3802    the current linking stage.  */
3803
3804 static bfd_size_type
3805 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3806 {
3807   bfd_size_type count;
3808
3809   count = 0;
3810   if (bfd_link_pic (info)
3811       || elf_hash_table (info)->is_relocatable_executable)
3812     {
3813       asection *p;
3814       const struct elf_backend_data *bed;
3815
3816       bed = get_elf_backend_data (output_bfd);
3817       for (p = output_bfd->sections; p ; p = p->next)
3818         if ((p->flags & SEC_EXCLUDE) == 0
3819             && (p->flags & SEC_ALLOC) != 0
3820             && elf_hash_table (info)->dynamic_relocs
3821             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3822           ++count;
3823     }
3824   return count;
3825 }
3826
3827 /* Sort the dynamic symbol table so that symbols that need GOT entries
3828    appear towards the end.  */
3829
3830 static bfd_boolean
3831 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3832 {
3833   struct mips_elf_link_hash_table *htab;
3834   struct mips_elf_hash_sort_data hsd;
3835   struct mips_got_info *g;
3836
3837   htab = mips_elf_hash_table (info);
3838   BFD_ASSERT (htab != NULL);
3839
3840   if (htab->root.dynsymcount == 0)
3841     return TRUE;
3842
3843   g = htab->got_info;
3844   if (g == NULL)
3845     return TRUE;
3846
3847   hsd.low = NULL;
3848   hsd.max_unref_got_dynindx
3849     = hsd.min_got_dynindx
3850     = (htab->root.dynsymcount - g->reloc_only_gotno);
3851   /* Add 1 to local symbol indices to account for the mandatory NULL entry
3852      at the head of the table; see `_bfd_elf_link_renumber_dynsyms'.  */
3853   hsd.max_local_dynindx = count_section_dynsyms (abfd, info) + 1;
3854   hsd.max_non_got_dynindx = htab->root.local_dynsymcount + 1;
3855   mips_elf_link_hash_traverse (htab, mips_elf_sort_hash_table_f, &hsd);
3856
3857   /* There should have been enough room in the symbol table to
3858      accommodate both the GOT and non-GOT symbols.  */
3859   BFD_ASSERT (hsd.max_local_dynindx <= htab->root.local_dynsymcount + 1);
3860   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3861   BFD_ASSERT (hsd.max_unref_got_dynindx == htab->root.dynsymcount);
3862   BFD_ASSERT (htab->root.dynsymcount - hsd.min_got_dynindx == g->global_gotno);
3863
3864   /* Now we know which dynamic symbol has the lowest dynamic symbol
3865      table index in the GOT.  */
3866   htab->global_gotsym = hsd.low;
3867
3868   return TRUE;
3869 }
3870
3871 /* If H needs a GOT entry, assign it the highest available dynamic
3872    index.  Otherwise, assign it the lowest available dynamic
3873    index.  */
3874
3875 static bfd_boolean
3876 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3877 {
3878   struct mips_elf_hash_sort_data *hsd = data;
3879
3880   /* Symbols without dynamic symbol table entries aren't interesting
3881      at all.  */
3882   if (h->root.dynindx == -1)
3883     return TRUE;
3884
3885   switch (h->global_got_area)
3886     {
3887     case GGA_NONE:
3888       if (h->root.forced_local)
3889         h->root.dynindx = hsd->max_local_dynindx++;
3890       else
3891         h->root.dynindx = hsd->max_non_got_dynindx++;
3892       break;
3893
3894     case GGA_NORMAL:
3895       h->root.dynindx = --hsd->min_got_dynindx;
3896       hsd->low = (struct elf_link_hash_entry *) h;
3897       break;
3898
3899     case GGA_RELOC_ONLY:
3900       if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3901         hsd->low = (struct elf_link_hash_entry *) h;
3902       h->root.dynindx = hsd->max_unref_got_dynindx++;
3903       break;
3904     }
3905
3906   return TRUE;
3907 }
3908
3909 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3910    (which is owned by the caller and shouldn't be added to the
3911    hash table directly).  */
3912
3913 static bfd_boolean
3914 mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd,
3915                            struct mips_got_entry *lookup)
3916 {
3917   struct mips_elf_link_hash_table *htab;
3918   struct mips_got_entry *entry;
3919   struct mips_got_info *g;
3920   void **loc, **bfd_loc;
3921
3922   /* Make sure there's a slot for this entry in the master GOT.  */
3923   htab = mips_elf_hash_table (info);
3924   g = htab->got_info;
3925   loc = htab_find_slot (g->got_entries, lookup, INSERT);
3926   if (!loc)
3927     return FALSE;
3928
3929   /* Populate the entry if it isn't already.  */
3930   entry = (struct mips_got_entry *) *loc;
3931   if (!entry)
3932     {
3933       entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3934       if (!entry)
3935         return FALSE;
3936
3937       lookup->tls_initialized = FALSE;
3938       lookup->gotidx = -1;
3939       *entry = *lookup;
3940       *loc = entry;
3941     }
3942
3943   /* Reuse the same GOT entry for the BFD's GOT.  */
3944   g = mips_elf_bfd_got (abfd, TRUE);
3945   if (!g)
3946     return FALSE;
3947
3948   bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT);
3949   if (!bfd_loc)
3950     return FALSE;
3951
3952   if (!*bfd_loc)
3953     *bfd_loc = entry;
3954   return TRUE;
3955 }
3956
3957 /* ABFD has a GOT relocation of type R_TYPE against H.  Reserve a GOT
3958    entry for it.  FOR_CALL is true if the caller is only interested in
3959    using the GOT entry for calls.  */
3960
3961 static bfd_boolean
3962 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3963                                    bfd *abfd, struct bfd_link_info *info,
3964                                    bfd_boolean for_call, int r_type)
3965 {
3966   struct mips_elf_link_hash_table *htab;
3967   struct mips_elf_link_hash_entry *hmips;
3968   struct mips_got_entry entry;
3969   unsigned char tls_type;
3970
3971   htab = mips_elf_hash_table (info);
3972   BFD_ASSERT (htab != NULL);
3973
3974   hmips = (struct mips_elf_link_hash_entry *) h;
3975   if (!for_call)
3976     hmips->got_only_for_calls = FALSE;
3977
3978   /* A global symbol in the GOT must also be in the dynamic symbol
3979      table.  */
3980   if (h->dynindx == -1)
3981     {
3982       switch (ELF_ST_VISIBILITY (h->other))
3983         {
3984         case STV_INTERNAL:
3985         case STV_HIDDEN:
3986           _bfd_mips_elf_hide_symbol (info, h, TRUE);
3987           break;
3988         }
3989       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3990         return FALSE;
3991     }
3992
3993   tls_type = mips_elf_reloc_tls_type (r_type);
3994   if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL)
3995     hmips->global_got_area = GGA_NORMAL;
3996
3997   entry.abfd = abfd;
3998   entry.symndx = -1;
3999   entry.d.h = (struct mips_elf_link_hash_entry *) h;
4000   entry.tls_type = tls_type;
4001   return mips_elf_record_got_entry (info, abfd, &entry);
4002 }
4003
4004 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
4005    where SYMNDX is a local symbol.  Reserve a GOT entry for it.  */
4006
4007 static bfd_boolean
4008 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
4009                                   struct bfd_link_info *info, int r_type)
4010 {
4011   struct mips_elf_link_hash_table *htab;
4012   struct mips_got_info *g;
4013   struct mips_got_entry entry;
4014
4015   htab = mips_elf_hash_table (info);
4016   BFD_ASSERT (htab != NULL);
4017
4018   g = htab->got_info;
4019   BFD_ASSERT (g != NULL);
4020
4021   entry.abfd = abfd;
4022   entry.symndx = symndx;
4023   entry.d.addend = addend;
4024   entry.tls_type = mips_elf_reloc_tls_type (r_type);
4025   return mips_elf_record_got_entry (info, abfd, &entry);
4026 }
4027
4028 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
4029    H is the symbol's hash table entry, or null if SYMNDX is local
4030    to ABFD.  */
4031
4032 static bfd_boolean
4033 mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd,
4034                               long symndx, struct elf_link_hash_entry *h,
4035                               bfd_signed_vma addend)
4036 {
4037   struct mips_elf_link_hash_table *htab;
4038   struct mips_got_info *g1, *g2;
4039   struct mips_got_page_ref lookup, *entry;
4040   void **loc, **bfd_loc;
4041
4042   htab = mips_elf_hash_table (info);
4043   BFD_ASSERT (htab != NULL);
4044
4045   g1 = htab->got_info;
4046   BFD_ASSERT (g1 != NULL);
4047
4048   if (h)
4049     {
4050       lookup.symndx = -1;
4051       lookup.u.h = (struct mips_elf_link_hash_entry *) h;
4052     }
4053   else
4054     {
4055       lookup.symndx = symndx;
4056       lookup.u.abfd = abfd;
4057     }
4058   lookup.addend = addend;
4059   loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT);
4060   if (loc == NULL)
4061     return FALSE;
4062
4063   entry = (struct mips_got_page_ref *) *loc;
4064   if (!entry)
4065     {
4066       entry = bfd_alloc (abfd, sizeof (*entry));
4067       if (!entry)
4068         return FALSE;
4069
4070       *entry = lookup;
4071       *loc = entry;
4072     }
4073
4074   /* Add the same entry to the BFD's GOT.  */
4075   g2 = mips_elf_bfd_got (abfd, TRUE);
4076   if (!g2)
4077     return FALSE;
4078
4079   bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT);
4080   if (!bfd_loc)
4081     return FALSE;
4082
4083   if (!*bfd_loc)
4084     *bfd_loc = entry;
4085
4086   return TRUE;
4087 }
4088
4089 /* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
4090
4091 static void
4092 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
4093                                        unsigned int n)
4094 {
4095   asection *s;
4096   struct mips_elf_link_hash_table *htab;
4097
4098   htab = mips_elf_hash_table (info);
4099   BFD_ASSERT (htab != NULL);
4100
4101   s = mips_elf_rel_dyn_section (info, FALSE);
4102   BFD_ASSERT (s != NULL);
4103
4104   if (htab->is_vxworks)
4105     s->size += n * MIPS_ELF_RELA_SIZE (abfd);
4106   else
4107     {
4108       if (s->size == 0)
4109         {
4110           /* Make room for a null element.  */
4111           s->size += MIPS_ELF_REL_SIZE (abfd);
4112           ++s->reloc_count;
4113         }
4114       s->size += n * MIPS_ELF_REL_SIZE (abfd);
4115     }
4116 }
4117 \f
4118 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4119    mips_elf_traverse_got_arg structure.  Count the number of GOT
4120    entries and TLS relocs.  Set DATA->value to true if we need
4121    to resolve indirect or warning symbols and then recreate the GOT.  */
4122
4123 static int
4124 mips_elf_check_recreate_got (void **entryp, void *data)
4125 {
4126   struct mips_got_entry *entry;
4127   struct mips_elf_traverse_got_arg *arg;
4128
4129   entry = (struct mips_got_entry *) *entryp;
4130   arg = (struct mips_elf_traverse_got_arg *) data;
4131   if (entry->abfd != NULL && entry->symndx == -1)
4132     {
4133       struct mips_elf_link_hash_entry *h;
4134
4135       h = entry->d.h;
4136       if (h->root.root.type == bfd_link_hash_indirect
4137           || h->root.root.type == bfd_link_hash_warning)
4138         {
4139           arg->value = TRUE;
4140           return 0;
4141         }
4142     }
4143   mips_elf_count_got_entry (arg->info, arg->g, entry);
4144   return 1;
4145 }
4146
4147 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4148    mips_elf_traverse_got_arg structure.  Add all entries to DATA->g,
4149    converting entries for indirect and warning symbols into entries
4150    for the target symbol.  Set DATA->g to null on error.  */
4151
4152 static int
4153 mips_elf_recreate_got (void **entryp, void *data)
4154 {
4155   struct mips_got_entry new_entry, *entry;
4156   struct mips_elf_traverse_got_arg *arg;
4157   void **slot;
4158
4159   entry = (struct mips_got_entry *) *entryp;
4160   arg = (struct mips_elf_traverse_got_arg *) data;
4161   if (entry->abfd != NULL
4162       && entry->symndx == -1
4163       && (entry->d.h->root.root.type == bfd_link_hash_indirect
4164           || entry->d.h->root.root.type == bfd_link_hash_warning))
4165     {
4166       struct mips_elf_link_hash_entry *h;
4167
4168       new_entry = *entry;
4169       entry = &new_entry;
4170       h = entry->d.h;
4171       do
4172         {
4173           BFD_ASSERT (h->global_got_area == GGA_NONE);
4174           h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4175         }
4176       while (h->root.root.type == bfd_link_hash_indirect
4177              || h->root.root.type == bfd_link_hash_warning);
4178       entry->d.h = h;
4179     }
4180   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4181   if (slot == NULL)
4182     {
4183       arg->g = NULL;
4184       return 0;
4185     }
4186   if (*slot == NULL)
4187     {
4188       if (entry == &new_entry)
4189         {
4190           entry = bfd_alloc (entry->abfd, sizeof (*entry));
4191           if (!entry)
4192             {
4193               arg->g = NULL;
4194               return 0;
4195             }
4196           *entry = new_entry;
4197         }
4198       *slot = entry;
4199       mips_elf_count_got_entry (arg->info, arg->g, entry);
4200     }
4201   return 1;
4202 }
4203
4204 /* Return the maximum number of GOT page entries required for RANGE.  */
4205
4206 static bfd_vma
4207 mips_elf_pages_for_range (const struct mips_got_page_range *range)
4208 {
4209   return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
4210 }
4211
4212 /* Record that G requires a page entry that can reach SEC + ADDEND.  */
4213
4214 static bfd_boolean
4215 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg,
4216                                 asection *sec, bfd_signed_vma addend)
4217 {
4218   struct mips_got_info *g = arg->g;
4219   struct mips_got_page_entry lookup, *entry;
4220   struct mips_got_page_range **range_ptr, *range;
4221   bfd_vma old_pages, new_pages;
4222   void **loc;
4223
4224   /* Find the mips_got_page_entry hash table entry for this section.  */
4225   lookup.sec = sec;
4226   loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
4227   if (loc == NULL)
4228     return FALSE;
4229
4230   /* Create a mips_got_page_entry if this is the first time we've
4231      seen the section.  */
4232   entry = (struct mips_got_page_entry *) *loc;
4233   if (!entry)
4234     {
4235       entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry));
4236       if (!entry)
4237         return FALSE;
4238
4239       entry->sec = sec;
4240       *loc = entry;
4241     }
4242
4243   /* Skip over ranges whose maximum extent cannot share a page entry
4244      with ADDEND.  */
4245   range_ptr = &entry->ranges;
4246   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4247     range_ptr = &(*range_ptr)->next;
4248
4249   /* If we scanned to the end of the list, or found a range whose
4250      minimum extent cannot share a page entry with ADDEND, create
4251      a new singleton range.  */
4252   range = *range_ptr;
4253   if (!range || addend < range->min_addend - 0xffff)
4254     {
4255       range = bfd_zalloc (arg->info->output_bfd, sizeof (*range));
4256       if (!range)
4257         return FALSE;
4258
4259       range->next = *range_ptr;
4260       range->min_addend = addend;
4261       range->max_addend = addend;
4262
4263       *range_ptr = range;
4264       entry->num_pages++;
4265       g->page_gotno++;
4266       return TRUE;
4267     }
4268
4269   /* Remember how many pages the old range contributed.  */
4270   old_pages = mips_elf_pages_for_range (range);
4271
4272   /* Update the ranges.  */
4273   if (addend < range->min_addend)
4274     range->min_addend = addend;
4275   else if (addend > range->max_addend)
4276     {
4277       if (range->next && addend >= range->next->min_addend - 0xffff)
4278         {
4279           old_pages += mips_elf_pages_for_range (range->next);
4280           range->max_addend = range->next->max_addend;
4281           range->next = range->next->next;
4282         }
4283       else
4284         range->max_addend = addend;
4285     }
4286
4287   /* Record any change in the total estimate.  */
4288   new_pages = mips_elf_pages_for_range (range);
4289   if (old_pages != new_pages)
4290     {
4291       entry->num_pages += new_pages - old_pages;
4292       g->page_gotno += new_pages - old_pages;
4293     }
4294
4295   return TRUE;
4296 }
4297
4298 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4299    and for which DATA points to a mips_elf_traverse_got_arg.  Work out
4300    whether the page reference described by *REFP needs a GOT page entry,
4301    and record that entry in DATA->g if so.  Set DATA->g to null on failure.  */
4302
4303 static bfd_boolean
4304 mips_elf_resolve_got_page_ref (void **refp, void *data)
4305 {
4306   struct mips_got_page_ref *ref;
4307   struct mips_elf_traverse_got_arg *arg;
4308   struct mips_elf_link_hash_table *htab;
4309   asection *sec;
4310   bfd_vma addend;
4311
4312   ref = (struct mips_got_page_ref *) *refp;
4313   arg = (struct mips_elf_traverse_got_arg *) data;
4314   htab = mips_elf_hash_table (arg->info);
4315
4316   if (ref->symndx < 0)
4317     {
4318       struct mips_elf_link_hash_entry *h;
4319
4320       /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries.  */
4321       h = ref->u.h;
4322       if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root))
4323         return 1;
4324
4325       /* Ignore undefined symbols; we'll issue an error later if
4326          appropriate.  */
4327       if (!((h->root.root.type == bfd_link_hash_defined
4328              || h->root.root.type == bfd_link_hash_defweak)
4329             && h->root.root.u.def.section))
4330         return 1;
4331
4332       sec = h->root.root.u.def.section;
4333       addend = h->root.root.u.def.value + ref->addend;
4334     }
4335   else
4336     {
4337       Elf_Internal_Sym *isym;
4338
4339       /* Read in the symbol.  */
4340       isym = bfd_sym_from_r_symndx (&htab->sym_cache, ref->u.abfd,
4341                                     ref->symndx);
4342       if (isym == NULL)
4343         {
4344           arg->g = NULL;
4345           return 0;
4346         }
4347
4348       /* Get the associated input section.  */
4349       sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx);
4350       if (sec == NULL)
4351         {
4352           arg->g = NULL;
4353           return 0;
4354         }
4355
4356       /* If this is a mergable section, work out the section and offset
4357          of the merged data.  For section symbols, the addend specifies
4358          of the offset _of_ the first byte in the data, otherwise it
4359          specifies the offset _from_ the first byte.  */
4360       if (sec->flags & SEC_MERGE)
4361         {
4362           void *secinfo;
4363
4364           secinfo = elf_section_data (sec)->sec_info;
4365           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4366             addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4367                                                  isym->st_value + ref->addend);
4368           else
4369             addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4370                                                  isym->st_value) + ref->addend;
4371         }
4372       else
4373         addend = isym->st_value + ref->addend;
4374     }
4375   if (!mips_elf_record_got_page_entry (arg, sec, addend))
4376     {
4377       arg->g = NULL;
4378       return 0;
4379     }
4380   return 1;
4381 }
4382
4383 /* If any entries in G->got_entries are for indirect or warning symbols,
4384    replace them with entries for the target symbol.  Convert g->got_page_refs
4385    into got_page_entry structures and estimate the number of page entries
4386    that they require.  */
4387
4388 static bfd_boolean
4389 mips_elf_resolve_final_got_entries (struct bfd_link_info *info,
4390                                     struct mips_got_info *g)
4391 {
4392   struct mips_elf_traverse_got_arg tga;
4393   struct mips_got_info oldg;
4394
4395   oldg = *g;
4396
4397   tga.info = info;
4398   tga.g = g;
4399   tga.value = FALSE;
4400   htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga);
4401   if (tga.value)
4402     {
4403       *g = oldg;
4404       g->got_entries = htab_create (htab_size (oldg.got_entries),
4405                                     mips_elf_got_entry_hash,
4406                                     mips_elf_got_entry_eq, NULL);
4407       if (!g->got_entries)
4408         return FALSE;
4409
4410       htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga);
4411       if (!tga.g)
4412         return FALSE;
4413
4414       htab_delete (oldg.got_entries);
4415     }
4416
4417   g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4418                                          mips_got_page_entry_eq, NULL);
4419   if (g->got_page_entries == NULL)
4420     return FALSE;
4421
4422   tga.info = info;
4423   tga.g = g;
4424   htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga);
4425
4426   return TRUE;
4427 }
4428
4429 /* Return true if a GOT entry for H should live in the local rather than
4430    global GOT area.  */
4431
4432 static bfd_boolean
4433 mips_use_local_got_p (struct bfd_link_info *info,
4434                       struct mips_elf_link_hash_entry *h)
4435 {
4436   /* Symbols that aren't in the dynamic symbol table must live in the
4437      local GOT.  This includes symbols that are completely undefined
4438      and which therefore don't bind locally.  We'll report undefined
4439      symbols later if appropriate.  */
4440   if (h->root.dynindx == -1)
4441     return TRUE;
4442
4443   /* Absolute symbols, if ever they need a GOT entry, cannot ever go
4444      to the local GOT, as they would be implicitly relocated by the
4445      base address by the dynamic loader.  */
4446   if (bfd_is_abs_symbol (&h->root.root))
4447     return FALSE;
4448
4449   /* Symbols that bind locally can (and in the case of forced-local
4450      symbols, must) live in the local GOT.  */
4451   if (h->got_only_for_calls
4452       ? SYMBOL_CALLS_LOCAL (info, &h->root)
4453       : SYMBOL_REFERENCES_LOCAL (info, &h->root))
4454     return TRUE;
4455
4456   /* If this is an executable that must provide a definition of the symbol,
4457      either though PLTs or copy relocations, then that address should go in
4458      the local rather than global GOT.  */
4459   if (bfd_link_executable (info) && h->has_static_relocs)
4460     return TRUE;
4461
4462   return FALSE;
4463 }
4464
4465 /* A mips_elf_link_hash_traverse callback for which DATA points to the
4466    link_info structure.  Decide whether the hash entry needs an entry in
4467    the global part of the primary GOT, setting global_got_area accordingly.
4468    Count the number of global symbols that are in the primary GOT only
4469    because they have relocations against them (reloc_only_gotno).  */
4470
4471 static int
4472 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4473 {
4474   struct bfd_link_info *info;
4475   struct mips_elf_link_hash_table *htab;
4476   struct mips_got_info *g;
4477
4478   info = (struct bfd_link_info *) data;
4479   htab = mips_elf_hash_table (info);
4480   g = htab->got_info;
4481   if (h->global_got_area != GGA_NONE)
4482     {
4483       /* Make a final decision about whether the symbol belongs in the
4484          local or global GOT.  */
4485       if (mips_use_local_got_p (info, h))
4486         /* The symbol belongs in the local GOT.  We no longer need this
4487            entry if it was only used for relocations; those relocations
4488            will be against the null or section symbol instead of H.  */
4489         h->global_got_area = GGA_NONE;
4490       else if (htab->is_vxworks
4491                && h->got_only_for_calls
4492                && h->root.plt.plist->mips_offset != MINUS_ONE)
4493         /* On VxWorks, calls can refer directly to the .got.plt entry;
4494            they don't need entries in the regular GOT.  .got.plt entries
4495            will be allocated by _bfd_mips_elf_adjust_dynamic_symbol.  */
4496         h->global_got_area = GGA_NONE;
4497       else if (h->global_got_area == GGA_RELOC_ONLY)
4498         {
4499           g->reloc_only_gotno++;
4500           g->global_gotno++;
4501         }
4502     }
4503   return 1;
4504 }
4505 \f
4506 /* A htab_traverse callback for GOT entries.  Add each one to the GOT
4507    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
4508
4509 static int
4510 mips_elf_add_got_entry (void **entryp, void *data)
4511 {
4512   struct mips_got_entry *entry;
4513   struct mips_elf_traverse_got_arg *arg;
4514   void **slot;
4515
4516   entry = (struct mips_got_entry *) *entryp;
4517   arg = (struct mips_elf_traverse_got_arg *) data;
4518   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4519   if (!slot)
4520     {
4521       arg->g = NULL;
4522       return 0;
4523     }
4524   if (!*slot)
4525     {
4526       *slot = entry;
4527       mips_elf_count_got_entry (arg->info, arg->g, entry);
4528     }
4529   return 1;
4530 }
4531
4532 /* A htab_traverse callback for GOT page entries.  Add each one to the GOT
4533    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
4534
4535 static int
4536 mips_elf_add_got_page_entry (void **entryp, void *data)
4537 {
4538   struct mips_got_page_entry *entry;
4539   struct mips_elf_traverse_got_arg *arg;
4540   void **slot;
4541
4542   entry = (struct mips_got_page_entry *) *entryp;
4543   arg = (struct mips_elf_traverse_got_arg *) data;
4544   slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT);
4545   if (!slot)
4546     {
4547       arg->g = NULL;
4548       return 0;
4549     }
4550   if (!*slot)
4551     {
4552       *slot = entry;
4553       arg->g->page_gotno += entry->num_pages;
4554     }
4555   return 1;
4556 }
4557
4558 /* Consider merging FROM, which is ABFD's GOT, into TO.  Return -1 if
4559    this would lead to overflow, 1 if they were merged successfully,
4560    and 0 if a merge failed due to lack of memory.  (These values are chosen
4561    so that nonnegative return values can be returned by a htab_traverse
4562    callback.)  */
4563
4564 static int
4565 mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from,
4566                          struct mips_got_info *to,
4567                          struct mips_elf_got_per_bfd_arg *arg)
4568 {
4569   struct mips_elf_traverse_got_arg tga;
4570   unsigned int estimate;
4571
4572   /* Work out how many page entries we would need for the combined GOT.  */
4573   estimate = arg->max_pages;
4574   if (estimate >= from->page_gotno + to->page_gotno)
4575     estimate = from->page_gotno + to->page_gotno;
4576
4577   /* And conservatively estimate how many local and TLS entries
4578      would be needed.  */
4579   estimate += from->local_gotno + to->local_gotno;
4580   estimate += from->tls_gotno + to->tls_gotno;
4581
4582   /* If we're merging with the primary got, any TLS relocations will
4583      come after the full set of global entries.  Otherwise estimate those
4584      conservatively as well.  */
4585   if (to == arg->primary && from->tls_gotno + to->tls_gotno)
4586     estimate += arg->global_count;
4587   else
4588     estimate += from->global_gotno + to->global_gotno;
4589
4590   /* Bail out if the combined GOT might be too big.  */
4591   if (estimate > arg->max_count)
4592     return -1;
4593
4594   /* Transfer the bfd's got information from FROM to TO.  */
4595   tga.info = arg->info;
4596   tga.g = to;
4597   htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga);
4598   if (!tga.g)
4599     return 0;
4600
4601   htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga);
4602   if (!tga.g)
4603     return 0;
4604
4605   mips_elf_replace_bfd_got (abfd, to);
4606   return 1;
4607 }
4608
4609 /* Attempt to merge GOT G, which belongs to ABFD.  Try to use as much
4610    as possible of the primary got, since it doesn't require explicit
4611    dynamic relocations, but don't use bfds that would reference global
4612    symbols out of the addressable range.  Failing the primary got,
4613    attempt to merge with the current got, or finish the current got
4614    and then make make the new got current.  */
4615
4616 static bfd_boolean
4617 mips_elf_merge_got (bfd *abfd, struct mips_got_info *g,
4618                     struct mips_elf_got_per_bfd_arg *arg)
4619 {
4620   unsigned int estimate;
4621   int result;
4622
4623   if (!mips_elf_resolve_final_got_entries (arg->info, g))
4624     return FALSE;
4625
4626   /* Work out the number of page, local and TLS entries.  */
4627   estimate = arg->max_pages;
4628   if (estimate > g->page_gotno)
4629     estimate = g->page_gotno;
4630   estimate += g->local_gotno + g->tls_gotno;
4631
4632   /* We place TLS GOT entries after both locals and globals.  The globals
4633      for the primary GOT may overflow the normal GOT size limit, so be
4634      sure not to merge a GOT which requires TLS with the primary GOT in that
4635      case.  This doesn't affect non-primary GOTs.  */
4636   estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4637
4638   if (estimate <= arg->max_count)
4639     {
4640       /* If we don't have a primary GOT, use it as
4641          a starting point for the primary GOT.  */
4642       if (!arg->primary)
4643         {
4644           arg->primary = g;
4645           return TRUE;
4646         }
4647
4648       /* Try merging with the primary GOT.  */
4649       result = mips_elf_merge_got_with (abfd, g, arg->primary, arg);
4650       if (result >= 0)
4651         return result;
4652     }
4653
4654   /* If we can merge with the last-created got, do it.  */
4655   if (arg->current)
4656     {
4657       result = mips_elf_merge_got_with (abfd, g, arg->current, arg);
4658       if (result >= 0)
4659         return result;
4660     }
4661
4662   /* Well, we couldn't merge, so create a new GOT.  Don't check if it
4663      fits; if it turns out that it doesn't, we'll get relocation
4664      overflows anyway.  */
4665   g->next = arg->current;
4666   arg->current = g;
4667
4668   return TRUE;
4669 }
4670
4671 /* ENTRYP is a hash table entry for a mips_got_entry.  Set its gotidx
4672    to GOTIDX, duplicating the entry if it has already been assigned
4673    an index in a different GOT.  */
4674
4675 static bfd_boolean
4676 mips_elf_set_gotidx (void **entryp, long gotidx)
4677 {
4678   struct mips_got_entry *entry;
4679
4680   entry = (struct mips_got_entry *) *entryp;
4681   if (entry->gotidx > 0)
4682     {
4683       struct mips_got_entry *new_entry;
4684
4685       new_entry = bfd_alloc (entry->abfd, sizeof (*entry));
4686       if (!new_entry)
4687         return FALSE;
4688
4689       *new_entry = *entry;
4690       *entryp = new_entry;
4691       entry = new_entry;
4692     }
4693   entry->gotidx = gotidx;
4694   return TRUE;
4695 }
4696
4697 /* Set the TLS GOT index for the GOT entry in ENTRYP.  DATA points to a
4698    mips_elf_traverse_got_arg in which DATA->value is the size of one
4699    GOT entry.  Set DATA->g to null on failure.  */
4700
4701 static int
4702 mips_elf_initialize_tls_index (void **entryp, void *data)
4703 {
4704   struct mips_got_entry *entry;
4705   struct mips_elf_traverse_got_arg *arg;
4706
4707   /* We're only interested in TLS symbols.  */
4708   entry = (struct mips_got_entry *) *entryp;
4709   if (entry->tls_type == GOT_TLS_NONE)
4710     return 1;
4711
4712   arg = (struct mips_elf_traverse_got_arg *) data;
4713   if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno))
4714     {
4715       arg->g = NULL;
4716       return 0;
4717     }
4718
4719   /* Account for the entries we've just allocated.  */
4720   arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type);
4721   return 1;
4722 }
4723
4724 /* A htab_traverse callback for GOT entries, where DATA points to a
4725    mips_elf_traverse_got_arg.  Set the global_got_area of each global
4726    symbol to DATA->value.  */
4727
4728 static int
4729 mips_elf_set_global_got_area (void **entryp, void *data)
4730 {
4731   struct mips_got_entry *entry;
4732   struct mips_elf_traverse_got_arg *arg;
4733
4734   entry = (struct mips_got_entry *) *entryp;
4735   arg = (struct mips_elf_traverse_got_arg *) data;
4736   if (entry->abfd != NULL
4737       && entry->symndx == -1
4738       && entry->d.h->global_got_area != GGA_NONE)
4739     entry->d.h->global_got_area = arg->value;
4740   return 1;
4741 }
4742
4743 /* A htab_traverse callback for secondary GOT entries, where DATA points
4744    to a mips_elf_traverse_got_arg.  Assign GOT indices to global entries
4745    and record the number of relocations they require.  DATA->value is
4746    the size of one GOT entry.  Set DATA->g to null on failure.  */
4747
4748 static int
4749 mips_elf_set_global_gotidx (void **entryp, void *data)
4750 {
4751   struct mips_got_entry *entry;
4752   struct mips_elf_traverse_got_arg *arg;
4753
4754   entry = (struct mips_got_entry *) *entryp;
4755   arg = (struct mips_elf_traverse_got_arg *) data;
4756   if (entry->abfd != NULL
4757       && entry->symndx == -1
4758       && entry->d.h->global_got_area != GGA_NONE)
4759     {
4760       if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno))
4761         {
4762           arg->g = NULL;
4763           return 0;
4764         }
4765       arg->g->assigned_low_gotno += 1;
4766
4767       if (bfd_link_pic (arg->info)
4768           || (elf_hash_table (arg->info)->dynamic_sections_created
4769               && entry->d.h->root.def_dynamic
4770               && !entry->d.h->root.def_regular))
4771         arg->g->relocs += 1;
4772     }
4773
4774   return 1;
4775 }
4776
4777 /* A htab_traverse callback for GOT entries for which DATA is the
4778    bfd_link_info.  Forbid any global symbols from having traditional
4779    lazy-binding stubs.  */
4780
4781 static int
4782 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4783 {
4784   struct bfd_link_info *info;
4785   struct mips_elf_link_hash_table *htab;
4786   struct mips_got_entry *entry;
4787
4788   entry = (struct mips_got_entry *) *entryp;
4789   info = (struct bfd_link_info *) data;
4790   htab = mips_elf_hash_table (info);
4791   BFD_ASSERT (htab != NULL);
4792
4793   if (entry->abfd != NULL
4794       && entry->symndx == -1
4795       && entry->d.h->needs_lazy_stub)
4796     {
4797       entry->d.h->needs_lazy_stub = FALSE;
4798       htab->lazy_stub_count--;
4799     }
4800
4801   return 1;
4802 }
4803
4804 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4805    the primary GOT.  */
4806 static bfd_vma
4807 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4808 {
4809   if (!g->next)
4810     return 0;
4811
4812   g = mips_elf_bfd_got (ibfd, FALSE);
4813   if (! g)
4814     return 0;
4815
4816   BFD_ASSERT (g->next);
4817
4818   g = g->next;
4819
4820   return (g->local_gotno + g->global_gotno + g->tls_gotno)
4821     * MIPS_ELF_GOT_SIZE (abfd);
4822 }
4823
4824 /* Turn a single GOT that is too big for 16-bit addressing into
4825    a sequence of GOTs, each one 16-bit addressable.  */
4826
4827 static bfd_boolean
4828 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4829                     asection *got, bfd_size_type pages)
4830 {
4831   struct mips_elf_link_hash_table *htab;
4832   struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4833   struct mips_elf_traverse_got_arg tga;
4834   struct mips_got_info *g, *gg;
4835   unsigned int assign, needed_relocs;
4836   bfd *dynobj, *ibfd;
4837
4838   dynobj = elf_hash_table (info)->dynobj;
4839   htab = mips_elf_hash_table (info);
4840   BFD_ASSERT (htab != NULL);
4841
4842   g = htab->got_info;
4843
4844   got_per_bfd_arg.obfd = abfd;
4845   got_per_bfd_arg.info = info;
4846   got_per_bfd_arg.current = NULL;
4847   got_per_bfd_arg.primary = NULL;
4848   got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4849                                 / MIPS_ELF_GOT_SIZE (abfd))
4850                                - htab->reserved_gotno);
4851   got_per_bfd_arg.max_pages = pages;
4852   /* The number of globals that will be included in the primary GOT.
4853      See the calls to mips_elf_set_global_got_area below for more
4854      information.  */
4855   got_per_bfd_arg.global_count = g->global_gotno;
4856
4857   /* Try to merge the GOTs of input bfds together, as long as they
4858      don't seem to exceed the maximum GOT size, choosing one of them
4859      to be the primary GOT.  */
4860   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4861     {
4862       gg = mips_elf_bfd_got (ibfd, FALSE);
4863       if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg))
4864         return FALSE;
4865     }
4866
4867   /* If we do not find any suitable primary GOT, create an empty one.  */
4868   if (got_per_bfd_arg.primary == NULL)
4869     g->next = mips_elf_create_got_info (abfd);
4870   else
4871     g->next = got_per_bfd_arg.primary;
4872   g->next->next = got_per_bfd_arg.current;
4873
4874   /* GG is now the master GOT, and G is the primary GOT.  */
4875   gg = g;
4876   g = g->next;
4877
4878   /* Map the output bfd to the primary got.  That's what we're going
4879      to use for bfds that use GOT16 or GOT_PAGE relocations that we
4880      didn't mark in check_relocs, and we want a quick way to find it.
4881      We can't just use gg->next because we're going to reverse the
4882      list.  */
4883   mips_elf_replace_bfd_got (abfd, g);
4884
4885   /* Every symbol that is referenced in a dynamic relocation must be
4886      present in the primary GOT, so arrange for them to appear after
4887      those that are actually referenced.  */
4888   gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4889   g->global_gotno = gg->global_gotno;
4890
4891   tga.info = info;
4892   tga.value = GGA_RELOC_ONLY;
4893   htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
4894   tga.value = GGA_NORMAL;
4895   htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
4896
4897   /* Now go through the GOTs assigning them offset ranges.
4898      [assigned_low_gotno, local_gotno[ will be set to the range of local
4899      entries in each GOT.  We can then compute the end of a GOT by
4900      adding local_gotno to global_gotno.  We reverse the list and make
4901      it circular since then we'll be able to quickly compute the
4902      beginning of a GOT, by computing the end of its predecessor.  To
4903      avoid special cases for the primary GOT, while still preserving
4904      assertions that are valid for both single- and multi-got links,
4905      we arrange for the main got struct to have the right number of
4906      global entries, but set its local_gotno such that the initial
4907      offset of the primary GOT is zero.  Remember that the primary GOT
4908      will become the last item in the circular linked list, so it
4909      points back to the master GOT.  */
4910   gg->local_gotno = -g->global_gotno;
4911   gg->global_gotno = g->global_gotno;
4912   gg->tls_gotno = 0;
4913   assign = 0;
4914   gg->next = gg;
4915
4916   do
4917     {
4918       struct mips_got_info *gn;
4919
4920       assign += htab->reserved_gotno;
4921       g->assigned_low_gotno = assign;
4922       g->local_gotno += assign;
4923       g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4924       g->assigned_high_gotno = g->local_gotno - 1;
4925       assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4926
4927       /* Take g out of the direct list, and push it onto the reversed
4928          list that gg points to.  g->next is guaranteed to be nonnull after
4929          this operation, as required by mips_elf_initialize_tls_index. */
4930       gn = g->next;
4931       g->next = gg->next;
4932       gg->next = g;
4933
4934       /* Set up any TLS entries.  We always place the TLS entries after
4935          all non-TLS entries.  */
4936       g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4937       tga.g = g;
4938       tga.value = MIPS_ELF_GOT_SIZE (abfd);
4939       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
4940       if (!tga.g)
4941         return FALSE;
4942       BFD_ASSERT (g->tls_assigned_gotno == assign);
4943
4944       /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
4945       g = gn;
4946
4947       /* Forbid global symbols in every non-primary GOT from having
4948          lazy-binding stubs.  */
4949       if (g)
4950         htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4951     }
4952   while (g);
4953
4954   got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
4955
4956   needed_relocs = 0;
4957   for (g = gg->next; g && g->next != gg; g = g->next)
4958     {
4959       unsigned int save_assign;
4960
4961       /* Assign offsets to global GOT entries and count how many
4962          relocations they need.  */
4963       save_assign = g->assigned_low_gotno;
4964       g->assigned_low_gotno = g->local_gotno;
4965       tga.info = info;
4966       tga.value = MIPS_ELF_GOT_SIZE (abfd);
4967       tga.g = g;
4968       htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
4969       if (!tga.g)
4970         return FALSE;
4971       BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno);
4972       g->assigned_low_gotno = save_assign;
4973
4974       if (bfd_link_pic (info))
4975         {
4976           g->relocs += g->local_gotno - g->assigned_low_gotno;
4977           BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno
4978                       + g->next->global_gotno
4979                       + g->next->tls_gotno
4980                       + htab->reserved_gotno);
4981         }
4982       needed_relocs += g->relocs;
4983     }
4984   needed_relocs += g->relocs;
4985
4986   if (needed_relocs)
4987     mips_elf_allocate_dynamic_relocations (dynobj, info,
4988                                            needed_relocs);
4989
4990   return TRUE;
4991 }
4992
4993 \f
4994 /* Returns the first relocation of type r_type found, beginning with
4995    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
4996
4997 static const Elf_Internal_Rela *
4998 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4999                           const Elf_Internal_Rela *relocation,
5000                           const Elf_Internal_Rela *relend)
5001 {
5002   unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
5003
5004   while (relocation < relend)
5005     {
5006       if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
5007           && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
5008         return relocation;
5009
5010       ++relocation;
5011     }
5012
5013   /* We didn't find it.  */
5014   return NULL;
5015 }
5016
5017 /* Return whether an input relocation is against a local symbol.  */
5018
5019 static bfd_boolean
5020 mips_elf_local_relocation_p (bfd *input_bfd,
5021                              const Elf_Internal_Rela *relocation,
5022                              asection **local_sections)
5023 {
5024   unsigned long r_symndx;
5025   Elf_Internal_Shdr *symtab_hdr;
5026   size_t extsymoff;
5027
5028   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5029   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5030   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5031
5032   if (r_symndx < extsymoff)
5033     return TRUE;
5034   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5035     return TRUE;
5036
5037   return FALSE;
5038 }
5039 \f
5040 /* Sign-extend VALUE, which has the indicated number of BITS.  */
5041
5042 bfd_vma
5043 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
5044 {
5045   if (value & ((bfd_vma) 1 << (bits - 1)))
5046     /* VALUE is negative.  */
5047     value |= ((bfd_vma) - 1) << bits;
5048
5049   return value;
5050 }
5051
5052 /* Return non-zero if the indicated VALUE has overflowed the maximum
5053    range expressible by a signed number with the indicated number of
5054    BITS.  */
5055
5056 static bfd_boolean
5057 mips_elf_overflow_p (bfd_vma value, int bits)
5058 {
5059   bfd_signed_vma svalue = (bfd_signed_vma) value;
5060
5061   if (svalue > (1 << (bits - 1)) - 1)
5062     /* The value is too big.  */
5063     return TRUE;
5064   else if (svalue < -(1 << (bits - 1)))
5065     /* The value is too small.  */
5066     return TRUE;
5067
5068   /* All is well.  */
5069   return FALSE;
5070 }
5071
5072 /* Calculate the %high function.  */
5073
5074 static bfd_vma
5075 mips_elf_high (bfd_vma value)
5076 {
5077   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5078 }
5079
5080 /* Calculate the %higher function.  */
5081
5082 static bfd_vma
5083 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
5084 {
5085 #ifdef BFD64
5086   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5087 #else
5088   abort ();
5089   return MINUS_ONE;
5090 #endif
5091 }
5092
5093 /* Calculate the %highest function.  */
5094
5095 static bfd_vma
5096 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
5097 {
5098 #ifdef BFD64
5099   return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
5100 #else
5101   abort ();
5102   return MINUS_ONE;
5103 #endif
5104 }
5105 \f
5106 /* Create the .compact_rel section.  */
5107
5108 static bfd_boolean
5109 mips_elf_create_compact_rel_section
5110   (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
5111 {
5112   flagword flags;
5113   register asection *s;
5114
5115   if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
5116     {
5117       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
5118                | SEC_READONLY);
5119
5120       s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
5121       if (s == NULL
5122           || ! bfd_set_section_alignment (abfd, s,
5123                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
5124         return FALSE;
5125
5126       s->size = sizeof (Elf32_External_compact_rel);
5127     }
5128
5129   return TRUE;
5130 }
5131
5132 /* Create the .got section to hold the global offset table.  */
5133
5134 static bfd_boolean
5135 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
5136 {
5137   flagword flags;
5138   register asection *s;
5139   struct elf_link_hash_entry *h;
5140   struct bfd_link_hash_entry *bh;
5141   struct mips_elf_link_hash_table *htab;
5142
5143   htab = mips_elf_hash_table (info);
5144   BFD_ASSERT (htab != NULL);
5145
5146   /* This function may be called more than once.  */
5147   if (htab->root.sgot)
5148     return TRUE;
5149
5150   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5151            | SEC_LINKER_CREATED);
5152
5153   /* We have to use an alignment of 2**4 here because this is hardcoded
5154      in the function stub generation and in the linker script.  */
5155   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
5156   if (s == NULL
5157       || ! bfd_set_section_alignment (abfd, s, 4))
5158     return FALSE;
5159   htab->root.sgot = s;
5160
5161   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
5162      linker script because we don't want to define the symbol if we
5163      are not creating a global offset table.  */
5164   bh = NULL;
5165   if (! (_bfd_generic_link_add_one_symbol
5166          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5167           0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5168     return FALSE;
5169
5170   h = (struct elf_link_hash_entry *) bh;
5171   h->non_elf = 0;
5172   h->def_regular = 1;
5173   h->type = STT_OBJECT;
5174   h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
5175   elf_hash_table (info)->hgot = h;
5176
5177   if (bfd_link_pic (info)
5178       && ! bfd_elf_link_record_dynamic_symbol (info, h))
5179     return FALSE;
5180
5181   htab->got_info = mips_elf_create_got_info (abfd);
5182   mips_elf_section_data (s)->elf.this_hdr.sh_flags
5183     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5184
5185   /* We also need a .got.plt section when generating PLTs.  */
5186   s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
5187                                           SEC_ALLOC | SEC_LOAD
5188                                           | SEC_HAS_CONTENTS
5189                                           | SEC_IN_MEMORY
5190                                           | SEC_LINKER_CREATED);
5191   if (s == NULL)
5192     return FALSE;
5193   htab->root.sgotplt = s;
5194
5195   return TRUE;
5196 }
5197 \f
5198 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5199    __GOTT_INDEX__ symbols.  These symbols are only special for
5200    shared objects; they are not used in executables.  */
5201
5202 static bfd_boolean
5203 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
5204 {
5205   return (mips_elf_hash_table (info)->is_vxworks
5206           && bfd_link_pic (info)
5207           && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
5208               || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
5209 }
5210
5211 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5212    require an la25 stub.  See also mips_elf_local_pic_function_p,
5213    which determines whether the destination function ever requires a
5214    stub.  */
5215
5216 static bfd_boolean
5217 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
5218                                      bfd_boolean target_is_16_bit_code_p)
5219 {
5220   /* We specifically ignore branches and jumps from EF_PIC objects,
5221      where the onus is on the compiler or programmer to perform any
5222      necessary initialization of $25.  Sometimes such initialization
5223      is unnecessary; for example, -mno-shared functions do not use
5224      the incoming value of $25, and may therefore be called directly.  */
5225   if (PIC_OBJECT_P (input_bfd))
5226     return FALSE;
5227
5228   switch (r_type)
5229     {
5230     case R_MIPS_26:
5231     case R_MIPS_PC16:
5232     case R_MIPS_PC21_S2:
5233     case R_MIPS_PC26_S2:
5234     case R_MICROMIPS_26_S1:
5235     case R_MICROMIPS_PC7_S1:
5236     case R_MICROMIPS_PC10_S1:
5237     case R_MICROMIPS_PC16_S1:
5238     case R_MICROMIPS_PC23_S2:
5239       return TRUE;
5240
5241     case R_MIPS16_26:
5242       return !target_is_16_bit_code_p;
5243
5244     default:
5245       return FALSE;
5246     }
5247 }
5248 \f
5249 /* Obtain the field relocated by RELOCATION.  */
5250
5251 static bfd_vma
5252 mips_elf_obtain_contents (reloc_howto_type *howto,
5253                           const Elf_Internal_Rela *relocation,
5254                           bfd *input_bfd, bfd_byte *contents)
5255 {
5256   bfd_vma x = 0;
5257   bfd_byte *location = contents + relocation->r_offset;
5258   unsigned int size = bfd_get_reloc_size (howto);
5259
5260   /* Obtain the bytes.  */
5261   if (size != 0)
5262     x = bfd_get (8 * size, input_bfd, location);
5263
5264   return x;
5265 }
5266
5267 /* Store the field relocated by RELOCATION.  */
5268
5269 static void
5270 mips_elf_store_contents (reloc_howto_type *howto,
5271                          const Elf_Internal_Rela *relocation,
5272                          bfd *input_bfd, bfd_byte *contents, bfd_vma x)
5273 {
5274   bfd_byte *location = contents + relocation->r_offset;
5275   unsigned int size = bfd_get_reloc_size (howto);
5276
5277   /* Put the value into the output.  */
5278   if (size != 0)
5279     bfd_put (8 * size, input_bfd, x, location);
5280 }
5281
5282 /* Try to patch a load from GOT instruction in CONTENTS pointed to by
5283    RELOCATION described by HOWTO, with a move of 0 to the load target
5284    register, returning TRUE if that is successful and FALSE otherwise.
5285    If DOIT is FALSE, then only determine it patching is possible and
5286    return status without actually changing CONTENTS.
5287 */
5288
5289 static bfd_boolean
5290 mips_elf_nullify_got_load (bfd *input_bfd, bfd_byte *contents,
5291                            const Elf_Internal_Rela *relocation,
5292                            reloc_howto_type *howto, bfd_boolean doit)
5293 {
5294   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5295   bfd_byte *location = contents + relocation->r_offset;
5296   bfd_boolean nullified = TRUE;
5297   bfd_vma x;
5298
5299   _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5300
5301   /* Obtain the current value.  */
5302   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5303
5304   /* Note that in the unshuffled MIPS16 encoding RX is at bits [21:19]
5305      while RY is at bits [18:16] of the combined 32-bit instruction word.  */
5306   if (mips16_reloc_p (r_type)
5307       && (((x >> 22) & 0x3ff) == 0x3d3                          /* LW */
5308           || ((x >> 22) & 0x3ff) == 0x3c7))                     /* LD */
5309     x = (0x3cd << 22) | (x & (7 << 16)) << 3;                   /* LI */
5310   else if (micromips_reloc_p (r_type)
5311            && ((x >> 26) & 0x37) == 0x37)                       /* LW/LD */
5312     x = (0xc << 26) | (x & (0x1f << 21));                       /* ADDIU */
5313   else if (((x >> 26) & 0x3f) == 0x23                           /* LW */
5314            || ((x >> 26) & 0x3f) == 0x37)                       /* LD */
5315     x = (0x9 << 26) | (x & (0x1f << 16));                       /* ADDIU */
5316   else
5317     nullified = FALSE;
5318
5319   /* Put the value into the output.  */
5320   if (doit && nullified)
5321     mips_elf_store_contents (howto, relocation, input_bfd, contents, x);
5322
5323   _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, FALSE, location);
5324
5325   return nullified;
5326 }
5327
5328 /* Calculate the value produced by the RELOCATION (which comes from
5329    the INPUT_BFD).  The ADDEND is the addend to use for this
5330    RELOCATION; RELOCATION->R_ADDEND is ignored.
5331
5332    The result of the relocation calculation is stored in VALUEP.
5333    On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5334    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5335
5336    This function returns bfd_reloc_continue if the caller need take no
5337    further action regarding this relocation, bfd_reloc_notsupported if
5338    something goes dramatically wrong, bfd_reloc_overflow if an
5339    overflow occurs, and bfd_reloc_ok to indicate success.  */
5340
5341 static bfd_reloc_status_type
5342 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
5343                                asection *input_section, bfd_byte *contents,
5344                                struct bfd_link_info *info,
5345                                const Elf_Internal_Rela *relocation,
5346                                bfd_vma addend, reloc_howto_type *howto,
5347                                Elf_Internal_Sym *local_syms,
5348                                asection **local_sections, bfd_vma *valuep,
5349                                const char **namep,
5350                                bfd_boolean *cross_mode_jump_p,
5351                                bfd_boolean save_addend)
5352 {
5353   /* The eventual value we will return.  */
5354   bfd_vma value;
5355   /* The address of the symbol against which the relocation is
5356      occurring.  */
5357   bfd_vma symbol = 0;
5358   /* The final GP value to be used for the relocatable, executable, or
5359      shared object file being produced.  */
5360   bfd_vma gp;
5361   /* The place (section offset or address) of the storage unit being
5362      relocated.  */
5363   bfd_vma p;
5364   /* The value of GP used to create the relocatable object.  */
5365   bfd_vma gp0;
5366   /* The offset into the global offset table at which the address of
5367      the relocation entry symbol, adjusted by the addend, resides
5368      during execution.  */
5369   bfd_vma g = MINUS_ONE;
5370   /* The section in which the symbol referenced by the relocation is
5371      located.  */
5372   asection *sec = NULL;
5373   struct mips_elf_link_hash_entry *h = NULL;
5374   /* TRUE if the symbol referred to by this relocation is a local
5375      symbol.  */
5376   bfd_boolean local_p, was_local_p;
5377   /* TRUE if the symbol referred to by this relocation is a section
5378      symbol.  */
5379   bfd_boolean section_p = FALSE;
5380   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
5381   bfd_boolean gp_disp_p = FALSE;
5382   /* TRUE if the symbol referred to by this relocation is
5383      "__gnu_local_gp".  */
5384   bfd_boolean gnu_local_gp_p = FALSE;
5385   Elf_Internal_Shdr *symtab_hdr;
5386   size_t extsymoff;
5387   unsigned long r_symndx;
5388   int r_type;
5389   /* TRUE if overflow occurred during the calculation of the
5390      relocation value.  */
5391   bfd_boolean overflowed_p;
5392   /* TRUE if this relocation refers to a MIPS16 function.  */
5393   bfd_boolean target_is_16_bit_code_p = FALSE;
5394   bfd_boolean target_is_micromips_code_p = FALSE;
5395   struct mips_elf_link_hash_table *htab;
5396   bfd *dynobj;
5397   bfd_boolean resolved_to_zero;
5398
5399   dynobj = elf_hash_table (info)->dynobj;
5400   htab = mips_elf_hash_table (info);
5401   BFD_ASSERT (htab != NULL);
5402
5403   /* Parse the relocation.  */
5404   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5405   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5406   p = (input_section->output_section->vma
5407        + input_section->output_offset
5408        + relocation->r_offset);
5409
5410   /* Assume that there will be no overflow.  */
5411   overflowed_p = FALSE;
5412
5413   /* Figure out whether or not the symbol is local, and get the offset
5414      used in the array of hash table entries.  */
5415   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5416   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5417                                          local_sections);
5418   was_local_p = local_p;
5419   if (! elf_bad_symtab (input_bfd))
5420     extsymoff = symtab_hdr->sh_info;
5421   else
5422     {
5423       /* The symbol table does not follow the rule that local symbols
5424          must come before globals.  */
5425       extsymoff = 0;
5426     }
5427
5428   /* Figure out the value of the symbol.  */
5429   if (local_p)
5430     {
5431       bfd_boolean micromips_p = MICROMIPS_P (abfd);
5432       Elf_Internal_Sym *sym;
5433
5434       sym = local_syms + r_symndx;
5435       sec = local_sections[r_symndx];
5436
5437       section_p = ELF_ST_TYPE (sym->st_info) == STT_SECTION;
5438
5439       symbol = sec->output_section->vma + sec->output_offset;
5440       if (!section_p || (sec->flags & SEC_MERGE))
5441         symbol += sym->st_value;
5442       if ((sec->flags & SEC_MERGE) && section_p)
5443         {
5444           addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5445           addend -= symbol;
5446           addend += sec->output_section->vma + sec->output_offset;
5447         }
5448
5449       /* MIPS16/microMIPS text labels should be treated as odd.  */
5450       if (ELF_ST_IS_COMPRESSED (sym->st_other))
5451         ++symbol;
5452
5453       /* Record the name of this symbol, for our caller.  */
5454       *namep = bfd_elf_string_from_elf_section (input_bfd,
5455                                                 symtab_hdr->sh_link,
5456                                                 sym->st_name);
5457       if (*namep == NULL || **namep == '\0')
5458         *namep = bfd_section_name (input_bfd, sec);
5459
5460       /* For relocations against a section symbol and ones against no
5461          symbol (absolute relocations) infer the ISA mode from the addend.  */
5462       if (section_p || r_symndx == STN_UNDEF)
5463         {
5464           target_is_16_bit_code_p = (addend & 1) && !micromips_p;
5465           target_is_micromips_code_p = (addend & 1) && micromips_p;
5466         }
5467       /* For relocations against an absolute symbol infer the ISA mode
5468          from the value of the symbol plus addend.  */
5469       else if (bfd_is_abs_section (sec))
5470         {
5471           target_is_16_bit_code_p = ((symbol + addend) & 1) && !micromips_p;
5472           target_is_micromips_code_p = ((symbol + addend) & 1) && micromips_p;
5473         }
5474       /* Otherwise just use the regular symbol annotation available.  */
5475       else
5476         {
5477           target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5478           target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5479         }
5480     }
5481   else
5482     {
5483       /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
5484
5485       /* For global symbols we look up the symbol in the hash-table.  */
5486       h = ((struct mips_elf_link_hash_entry *)
5487            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5488       /* Find the real hash-table entry for this symbol.  */
5489       while (h->root.root.type == bfd_link_hash_indirect
5490              || h->root.root.type == bfd_link_hash_warning)
5491         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5492
5493       /* Record the name of this symbol, for our caller.  */
5494       *namep = h->root.root.root.string;
5495
5496       /* See if this is the special _gp_disp symbol.  Note that such a
5497          symbol must always be a global symbol.  */
5498       if (strcmp (*namep, "_gp_disp") == 0
5499           && ! NEWABI_P (input_bfd))
5500         {
5501           /* Relocations against _gp_disp are permitted only with
5502              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
5503           if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5504             return bfd_reloc_notsupported;
5505
5506           gp_disp_p = TRUE;
5507         }
5508       /* See if this is the special _gp symbol.  Note that such a
5509          symbol must always be a global symbol.  */
5510       else if (strcmp (*namep, "__gnu_local_gp") == 0)
5511         gnu_local_gp_p = TRUE;
5512
5513
5514       /* If this symbol is defined, calculate its address.  Note that
5515          _gp_disp is a magic symbol, always implicitly defined by the
5516          linker, so it's inappropriate to check to see whether or not
5517          its defined.  */
5518       else if ((h->root.root.type == bfd_link_hash_defined
5519                 || h->root.root.type == bfd_link_hash_defweak)
5520                && h->root.root.u.def.section)
5521         {
5522           sec = h->root.root.u.def.section;
5523           if (sec->output_section)
5524             symbol = (h->root.root.u.def.value
5525                       + sec->output_section->vma
5526                       + sec->output_offset);
5527           else
5528             symbol = h->root.root.u.def.value;
5529         }
5530       else if (h->root.root.type == bfd_link_hash_undefweak)
5531         /* We allow relocations against undefined weak symbols, giving
5532            it the value zero, so that you can undefined weak functions
5533            and check to see if they exist by looking at their
5534            addresses.  */
5535         symbol = 0;
5536       else if (info->unresolved_syms_in_objects == RM_IGNORE
5537                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5538         symbol = 0;
5539       else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5540                        ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5541         {
5542           /* If this is a dynamic link, we should have created a
5543              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5544              in _bfd_mips_elf_create_dynamic_sections.
5545              Otherwise, we should define the symbol with a value of 0.
5546              FIXME: It should probably get into the symbol table
5547              somehow as well.  */
5548           BFD_ASSERT (! bfd_link_pic (info));
5549           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5550           symbol = 0;
5551         }
5552       else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5553         {
5554           /* This is an optional symbol - an Irix specific extension to the
5555              ELF spec.  Ignore it for now.
5556              XXX - FIXME - there is more to the spec for OPTIONAL symbols
5557              than simply ignoring them, but we do not handle this for now.
5558              For information see the "64-bit ELF Object File Specification"
5559              which is available from here:
5560              http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
5561           symbol = 0;
5562         }
5563       else
5564         {
5565           bfd_boolean reject_undefined
5566             = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
5567                || ELF_ST_VISIBILITY (h->root.other) != STV_DEFAULT);
5568
5569           (*info->callbacks->undefined_symbol)
5570             (info, h->root.root.root.string, input_bfd,
5571              input_section, relocation->r_offset, reject_undefined);
5572
5573           if (reject_undefined)
5574             return bfd_reloc_undefined;
5575
5576           symbol = 0;
5577         }
5578
5579       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5580       target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other);
5581     }
5582
5583   /* If this is a reference to a 16-bit function with a stub, we need
5584      to redirect the relocation to the stub unless:
5585
5586      (a) the relocation is for a MIPS16 JAL;
5587
5588      (b) the relocation is for a MIPS16 PIC call, and there are no
5589          non-MIPS16 uses of the GOT slot; or
5590
5591      (c) the section allows direct references to MIPS16 functions.  */
5592   if (r_type != R_MIPS16_26
5593       && !bfd_link_relocatable (info)
5594       && ((h != NULL
5595            && h->fn_stub != NULL
5596            && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5597           || (local_p
5598               && mips_elf_tdata (input_bfd)->local_stubs != NULL
5599               && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5600       && !section_allows_mips16_refs_p (input_section))
5601     {
5602       /* This is a 32- or 64-bit call to a 16-bit function.  We should
5603          have already noticed that we were going to need the
5604          stub.  */
5605       if (local_p)
5606         {
5607           sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx];
5608           value = 0;
5609         }
5610       else
5611         {
5612           BFD_ASSERT (h->need_fn_stub);
5613           if (h->la25_stub)
5614             {
5615               /* If a LA25 header for the stub itself exists, point to the
5616                  prepended LUI/ADDIU sequence.  */
5617               sec = h->la25_stub->stub_section;
5618               value = h->la25_stub->offset;
5619             }
5620           else
5621             {
5622               sec = h->fn_stub;
5623               value = 0;
5624             }
5625         }
5626
5627       symbol = sec->output_section->vma + sec->output_offset + value;
5628       /* The target is 16-bit, but the stub isn't.  */
5629       target_is_16_bit_code_p = FALSE;
5630     }
5631   /* If this is a MIPS16 call with a stub, that is made through the PLT or
5632      to a standard MIPS function, we need to redirect the call to the stub.
5633      Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5634      indirect calls should use an indirect stub instead.  */
5635   else if (r_type == R_MIPS16_26 && !bfd_link_relocatable (info)
5636            && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5637                || (local_p
5638                    && mips_elf_tdata (input_bfd)->local_call_stubs != NULL
5639                    && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5640            && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p))
5641     {
5642       if (local_p)
5643         sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5644       else
5645         {
5646           /* If both call_stub and call_fp_stub are defined, we can figure
5647              out which one to use by checking which one appears in the input
5648              file.  */
5649           if (h->call_stub != NULL && h->call_fp_stub != NULL)
5650             {
5651               asection *o;
5652
5653               sec = NULL;
5654               for (o = input_bfd->sections; o != NULL; o = o->next)
5655                 {
5656                   if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5657                     {
5658                       sec = h->call_fp_stub;
5659                       break;
5660                     }
5661                 }
5662               if (sec == NULL)
5663                 sec = h->call_stub;
5664             }
5665           else if (h->call_stub != NULL)
5666             sec = h->call_stub;
5667           else
5668             sec = h->call_fp_stub;
5669         }
5670
5671       BFD_ASSERT (sec->size > 0);
5672       symbol = sec->output_section->vma + sec->output_offset;
5673     }
5674   /* If this is a direct call to a PIC function, redirect to the
5675      non-PIC stub.  */
5676   else if (h != NULL && h->la25_stub
5677            && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5678                                                    target_is_16_bit_code_p))
5679     {
5680         symbol = (h->la25_stub->stub_section->output_section->vma
5681                   + h->la25_stub->stub_section->output_offset
5682                   + h->la25_stub->offset);
5683         if (ELF_ST_IS_MICROMIPS (h->root.other))
5684           symbol |= 1;
5685     }
5686   /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5687      entry is used if a standard PLT entry has also been made.  In this
5688      case the symbol will have been set by mips_elf_set_plt_sym_value
5689      to point to the standard PLT entry, so redirect to the compressed
5690      one.  */
5691   else if ((mips16_branch_reloc_p (r_type)
5692             || micromips_branch_reloc_p (r_type))
5693            && !bfd_link_relocatable (info)
5694            && h != NULL
5695            && h->use_plt_entry
5696            && h->root.plt.plist->comp_offset != MINUS_ONE
5697            && h->root.plt.plist->mips_offset != MINUS_ONE)
5698     {
5699       bfd_boolean micromips_p = MICROMIPS_P (abfd);
5700
5701       sec = htab->root.splt;
5702       symbol = (sec->output_section->vma
5703                 + sec->output_offset
5704                 + htab->plt_header_size
5705                 + htab->plt_mips_offset
5706                 + h->root.plt.plist->comp_offset
5707                 + 1);
5708
5709       target_is_16_bit_code_p = !micromips_p;
5710       target_is_micromips_code_p = micromips_p;
5711     }
5712
5713   /* Make sure MIPS16 and microMIPS are not used together.  */
5714   if ((mips16_branch_reloc_p (r_type) && target_is_micromips_code_p)
5715       || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5716    {
5717       _bfd_error_handler
5718         (_("MIPS16 and microMIPS functions cannot call each other"));
5719       return bfd_reloc_notsupported;
5720    }
5721
5722   /* Calls from 16-bit code to 32-bit code and vice versa require the
5723      mode change.  However, we can ignore calls to undefined weak symbols,
5724      which should never be executed at runtime.  This exception is important
5725      because the assembly writer may have "known" that any definition of the
5726      symbol would be 16-bit code, and that direct jumps were therefore
5727      acceptable.  */
5728   *cross_mode_jump_p = (!bfd_link_relocatable (info)
5729                         && !(h && h->root.root.type == bfd_link_hash_undefweak)
5730                         && ((mips16_branch_reloc_p (r_type)
5731                              && !target_is_16_bit_code_p)
5732                             || (micromips_branch_reloc_p (r_type)
5733                                 && !target_is_micromips_code_p)
5734                             || ((branch_reloc_p (r_type)
5735                                  || r_type == R_MIPS_JALR)
5736                                 && (target_is_16_bit_code_p
5737                                     || target_is_micromips_code_p))));
5738
5739   resolved_to_zero = (h != NULL
5740                       && UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->root));
5741
5742   switch (r_type)
5743     {
5744     case R_MIPS16_CALL16:
5745     case R_MIPS16_GOT16:
5746     case R_MIPS_CALL16:
5747     case R_MIPS_GOT16:
5748     case R_MIPS_GOT_PAGE:
5749     case R_MIPS_GOT_DISP:
5750     case R_MIPS_GOT_LO16:
5751     case R_MIPS_CALL_LO16:
5752     case R_MICROMIPS_CALL16:
5753     case R_MICROMIPS_GOT16:
5754     case R_MICROMIPS_GOT_PAGE:
5755     case R_MICROMIPS_GOT_DISP:
5756     case R_MICROMIPS_GOT_LO16:
5757     case R_MICROMIPS_CALL_LO16:
5758       if (resolved_to_zero
5759           && !bfd_link_relocatable (info)
5760           && mips_elf_nullify_got_load (input_bfd, contents,
5761                                         relocation, howto, TRUE))
5762         return bfd_reloc_continue;
5763
5764       /* Fall through.  */
5765     case R_MIPS_GOT_HI16:
5766     case R_MIPS_CALL_HI16:
5767     case R_MICROMIPS_GOT_HI16:
5768     case R_MICROMIPS_CALL_HI16:
5769       if (resolved_to_zero
5770           && htab->use_absolute_zero
5771           && bfd_link_pic (info))
5772         {
5773           /* Redirect to the special `__gnu_absolute_zero' symbol.  */
5774           h = mips_elf_link_hash_lookup (htab, "__gnu_absolute_zero",
5775                                          FALSE, FALSE, FALSE);
5776           BFD_ASSERT (h != NULL);
5777         }
5778       break;
5779     }
5780
5781   local_p = (h == NULL || mips_use_local_got_p (info, h));
5782
5783   gp0 = _bfd_get_gp_value (input_bfd);
5784   gp = _bfd_get_gp_value (abfd);
5785   if (htab->got_info)
5786     gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5787
5788   if (gnu_local_gp_p)
5789     symbol = gp;
5790
5791   /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5792      to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
5793      corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.  */
5794   if (got_page_reloc_p (r_type) && !local_p)
5795     {
5796       r_type = (micromips_reloc_p (r_type)
5797                 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5798       addend = 0;
5799     }
5800
5801   /* If we haven't already determined the GOT offset, and we're going
5802      to need it, get it now.  */
5803   switch (r_type)
5804     {
5805     case R_MIPS16_CALL16:
5806     case R_MIPS16_GOT16:
5807     case R_MIPS_CALL16:
5808     case R_MIPS_GOT16:
5809     case R_MIPS_GOT_DISP:
5810     case R_MIPS_GOT_HI16:
5811     case R_MIPS_CALL_HI16:
5812     case R_MIPS_GOT_LO16:
5813     case R_MIPS_CALL_LO16:
5814     case R_MICROMIPS_CALL16:
5815     case R_MICROMIPS_GOT16:
5816     case R_MICROMIPS_GOT_DISP:
5817     case R_MICROMIPS_GOT_HI16:
5818     case R_MICROMIPS_CALL_HI16:
5819     case R_MICROMIPS_GOT_LO16:
5820     case R_MICROMIPS_CALL_LO16:
5821     case R_MIPS_TLS_GD:
5822     case R_MIPS_TLS_GOTTPREL:
5823     case R_MIPS_TLS_LDM:
5824     case R_MIPS16_TLS_GD:
5825     case R_MIPS16_TLS_GOTTPREL:
5826     case R_MIPS16_TLS_LDM:
5827     case R_MICROMIPS_TLS_GD:
5828     case R_MICROMIPS_TLS_GOTTPREL:
5829     case R_MICROMIPS_TLS_LDM:
5830       /* Find the index into the GOT where this value is located.  */
5831       if (tls_ldm_reloc_p (r_type))
5832         {
5833           g = mips_elf_local_got_index (abfd, input_bfd, info,
5834                                         0, 0, NULL, r_type);
5835           if (g == MINUS_ONE)
5836             return bfd_reloc_outofrange;
5837         }
5838       else if (!local_p)
5839         {
5840           /* On VxWorks, CALL relocations should refer to the .got.plt
5841              entry, which is initialized to point at the PLT stub.  */
5842           if (htab->is_vxworks
5843               && (call_hi16_reloc_p (r_type)
5844                   || call_lo16_reloc_p (r_type)
5845                   || call16_reloc_p (r_type)))
5846             {
5847               BFD_ASSERT (addend == 0);
5848               BFD_ASSERT (h->root.needs_plt);
5849               g = mips_elf_gotplt_index (info, &h->root);
5850             }
5851           else
5852             {
5853               BFD_ASSERT (addend == 0);
5854               g = mips_elf_global_got_index (abfd, info, input_bfd,
5855                                              &h->root, r_type);
5856               if (!TLS_RELOC_P (r_type)
5857                   && !elf_hash_table (info)->dynamic_sections_created)
5858                 /* This is a static link.  We must initialize the GOT entry.  */
5859                 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->root.sgot->contents + g);
5860             }
5861         }
5862       else if (!htab->is_vxworks
5863                && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5864         /* The calculation below does not involve "g".  */
5865         break;
5866       else
5867         {
5868           g = mips_elf_local_got_index (abfd, input_bfd, info,
5869                                         symbol + addend, r_symndx, h, r_type);
5870           if (g == MINUS_ONE)
5871             return bfd_reloc_outofrange;
5872         }
5873
5874       /* Convert GOT indices to actual offsets.  */
5875       g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5876       break;
5877     }
5878
5879   /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5880      symbols are resolved by the loader.  Add them to .rela.dyn.  */
5881   if (h != NULL && is_gott_symbol (info, &h->root))
5882     {
5883       Elf_Internal_Rela outrel;
5884       bfd_byte *loc;
5885       asection *s;
5886
5887       s = mips_elf_rel_dyn_section (info, FALSE);
5888       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5889
5890       outrel.r_offset = (input_section->output_section->vma
5891                          + input_section->output_offset
5892                          + relocation->r_offset);
5893       outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5894       outrel.r_addend = addend;
5895       bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5896
5897       /* If we've written this relocation for a readonly section,
5898          we need to set DF_TEXTREL again, so that we do not delete the
5899          DT_TEXTREL tag.  */
5900       if (MIPS_ELF_READONLY_SECTION (input_section))
5901         info->flags |= DF_TEXTREL;
5902
5903       *valuep = 0;
5904       return bfd_reloc_ok;
5905     }
5906
5907   /* Figure out what kind of relocation is being performed.  */
5908   switch (r_type)
5909     {
5910     case R_MIPS_NONE:
5911       return bfd_reloc_continue;
5912
5913     case R_MIPS_16:
5914       if (howto->partial_inplace)
5915         addend = _bfd_mips_elf_sign_extend (addend, 16);
5916       value = symbol + addend;
5917       overflowed_p = mips_elf_overflow_p (value, 16);
5918       break;
5919
5920     case R_MIPS_32:
5921     case R_MIPS_REL32:
5922     case R_MIPS_64:
5923       if ((bfd_link_pic (info)
5924            || (htab->root.dynamic_sections_created
5925                && h != NULL
5926                && h->root.def_dynamic
5927                && !h->root.def_regular
5928                && !h->has_static_relocs))
5929           && r_symndx != STN_UNDEF
5930           && (h == NULL
5931               || h->root.root.type != bfd_link_hash_undefweak
5932               || (ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
5933                   && !resolved_to_zero))
5934           && (input_section->flags & SEC_ALLOC) != 0)
5935         {
5936           /* If we're creating a shared library, then we can't know
5937              where the symbol will end up.  So, we create a relocation
5938              record in the output, and leave the job up to the dynamic
5939              linker.  We must do the same for executable references to
5940              shared library symbols, unless we've decided to use copy
5941              relocs or PLTs instead.  */
5942           value = addend;
5943           if (!mips_elf_create_dynamic_relocation (abfd,
5944                                                    info,
5945                                                    relocation,
5946                                                    h,
5947                                                    sec,
5948                                                    symbol,
5949                                                    &value,
5950                                                    input_section))
5951             return bfd_reloc_undefined;
5952         }
5953       else
5954         {
5955           if (r_type != R_MIPS_REL32)
5956             value = symbol + addend;
5957           else
5958             value = addend;
5959         }
5960       value &= howto->dst_mask;
5961       break;
5962
5963     case R_MIPS_PC32:
5964       value = symbol + addend - p;
5965       value &= howto->dst_mask;
5966       break;
5967
5968     case R_MIPS16_26:
5969       /* The calculation for R_MIPS16_26 is just the same as for an
5970          R_MIPS_26.  It's only the storage of the relocated field into
5971          the output file that's different.  That's handled in
5972          mips_elf_perform_relocation.  So, we just fall through to the
5973          R_MIPS_26 case here.  */
5974     case R_MIPS_26:
5975     case R_MICROMIPS_26_S1:
5976       {
5977         unsigned int shift;
5978
5979         /* Shift is 2, unusually, for microMIPS JALX.  */
5980         shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5981
5982         if (howto->partial_inplace && !section_p)
5983           value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5984         else
5985           value = addend;
5986         value += symbol;
5987
5988         /* Make sure the target of a jump is suitably aligned.  Bit 0 must
5989            be the correct ISA mode selector except for weak undefined
5990            symbols.  */
5991         if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5992             && (*cross_mode_jump_p
5993                 ? (value & 3) != (r_type == R_MIPS_26)
5994                 : (value & ((1 << shift) - 1)) != (r_type != R_MIPS_26)))
5995           return bfd_reloc_outofrange;
5996
5997         value >>= shift;
5998         if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5999           overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
6000         value &= howto->dst_mask;
6001       }
6002       break;
6003
6004     case R_MIPS_TLS_DTPREL_HI16:
6005     case R_MIPS16_TLS_DTPREL_HI16:
6006     case R_MICROMIPS_TLS_DTPREL_HI16:
6007       value = (mips_elf_high (addend + symbol - dtprel_base (info))
6008                & howto->dst_mask);
6009       break;
6010
6011     case R_MIPS_TLS_DTPREL_LO16:
6012     case R_MIPS_TLS_DTPREL32:
6013     case R_MIPS_TLS_DTPREL64:
6014     case R_MIPS16_TLS_DTPREL_LO16:
6015     case R_MICROMIPS_TLS_DTPREL_LO16:
6016       value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
6017       break;
6018
6019     case R_MIPS_TLS_TPREL_HI16:
6020     case R_MIPS16_TLS_TPREL_HI16:
6021     case R_MICROMIPS_TLS_TPREL_HI16:
6022       value = (mips_elf_high (addend + symbol - tprel_base (info))
6023                & howto->dst_mask);
6024       break;
6025
6026     case R_MIPS_TLS_TPREL_LO16:
6027     case R_MIPS_TLS_TPREL32:
6028     case R_MIPS_TLS_TPREL64:
6029     case R_MIPS16_TLS_TPREL_LO16:
6030     case R_MICROMIPS_TLS_TPREL_LO16:
6031       value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
6032       break;
6033
6034     case R_MIPS_HI16:
6035     case R_MIPS16_HI16:
6036     case R_MICROMIPS_HI16:
6037       if (!gp_disp_p)
6038         {
6039           value = mips_elf_high (addend + symbol);
6040           value &= howto->dst_mask;
6041         }
6042       else
6043         {
6044           /* For MIPS16 ABI code we generate this sequence
6045                 0: li      $v0,%hi(_gp_disp)
6046                 4: addiupc $v1,%lo(_gp_disp)
6047                 8: sll     $v0,16
6048                12: addu    $v0,$v1
6049                14: move    $gp,$v0
6050              So the offsets of hi and lo relocs are the same, but the
6051              base $pc is that used by the ADDIUPC instruction at $t9 + 4.
6052              ADDIUPC clears the low two bits of the instruction address,
6053              so the base is ($t9 + 4) & ~3.  */
6054           if (r_type == R_MIPS16_HI16)
6055             value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
6056           /* The microMIPS .cpload sequence uses the same assembly
6057              instructions as the traditional psABI version, but the
6058              incoming $t9 has the low bit set.  */
6059           else if (r_type == R_MICROMIPS_HI16)
6060             value = mips_elf_high (addend + gp - p - 1);
6061           else
6062             value = mips_elf_high (addend + gp - p);
6063         }
6064       break;
6065
6066     case R_MIPS_LO16:
6067     case R_MIPS16_LO16:
6068     case R_MICROMIPS_LO16:
6069     case R_MICROMIPS_HI0_LO16:
6070       if (!gp_disp_p)
6071         value = (symbol + addend) & howto->dst_mask;
6072       else
6073         {
6074           /* See the comment for R_MIPS16_HI16 above for the reason
6075              for this conditional.  */
6076           if (r_type == R_MIPS16_LO16)
6077             value = addend + gp - (p & ~(bfd_vma) 0x3);
6078           else if (r_type == R_MICROMIPS_LO16
6079                    || r_type == R_MICROMIPS_HI0_LO16)
6080             value = addend + gp - p + 3;
6081           else
6082             value = addend + gp - p + 4;
6083           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6084              for overflow.  But, on, say, IRIX5, relocations against
6085              _gp_disp are normally generated from the .cpload
6086              pseudo-op.  It generates code that normally looks like
6087              this:
6088
6089                lui    $gp,%hi(_gp_disp)
6090                addiu  $gp,$gp,%lo(_gp_disp)
6091                addu   $gp,$gp,$t9
6092
6093              Here $t9 holds the address of the function being called,
6094              as required by the MIPS ELF ABI.  The R_MIPS_LO16
6095              relocation can easily overflow in this situation, but the
6096              R_MIPS_HI16 relocation will handle the overflow.
6097              Therefore, we consider this a bug in the MIPS ABI, and do
6098              not check for overflow here.  */
6099         }
6100       break;
6101
6102     case R_MIPS_LITERAL:
6103     case R_MICROMIPS_LITERAL:
6104       /* Because we don't merge literal sections, we can handle this
6105          just like R_MIPS_GPREL16.  In the long run, we should merge
6106          shared literals, and then we will need to additional work
6107          here.  */
6108
6109       /* Fall through.  */
6110
6111     case R_MIPS16_GPREL:
6112       /* The R_MIPS16_GPREL performs the same calculation as
6113          R_MIPS_GPREL16, but stores the relocated bits in a different
6114          order.  We don't need to do anything special here; the
6115          differences are handled in mips_elf_perform_relocation.  */
6116     case R_MIPS_GPREL16:
6117     case R_MICROMIPS_GPREL7_S2:
6118     case R_MICROMIPS_GPREL16:
6119       /* Only sign-extend the addend if it was extracted from the
6120          instruction.  If the addend was separate, leave it alone,
6121          otherwise we may lose significant bits.  */
6122       if (howto->partial_inplace)
6123         addend = _bfd_mips_elf_sign_extend (addend, 16);
6124       value = symbol + addend - gp;
6125       /* If the symbol was local, any earlier relocatable links will
6126          have adjusted its addend with the gp offset, so compensate
6127          for that now.  Don't do it for symbols forced local in this
6128          link, though, since they won't have had the gp offset applied
6129          to them before.  */
6130       if (was_local_p)
6131         value += gp0;
6132       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6133         overflowed_p = mips_elf_overflow_p (value, 16);
6134       break;
6135
6136     case R_MIPS16_GOT16:
6137     case R_MIPS16_CALL16:
6138     case R_MIPS_GOT16:
6139     case R_MIPS_CALL16:
6140     case R_MICROMIPS_GOT16:
6141     case R_MICROMIPS_CALL16:
6142       /* VxWorks does not have separate local and global semantics for
6143          R_MIPS*_GOT16; every relocation evaluates to "G".  */
6144       if (!htab->is_vxworks && local_p)
6145         {
6146           value = mips_elf_got16_entry (abfd, input_bfd, info,
6147                                         symbol + addend, !was_local_p);
6148           if (value == MINUS_ONE)
6149             return bfd_reloc_outofrange;
6150           value
6151             = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6152           overflowed_p = mips_elf_overflow_p (value, 16);
6153           break;
6154         }
6155
6156       /* Fall through.  */
6157
6158     case R_MIPS_TLS_GD:
6159     case R_MIPS_TLS_GOTTPREL:
6160     case R_MIPS_TLS_LDM:
6161     case R_MIPS_GOT_DISP:
6162     case R_MIPS16_TLS_GD:
6163     case R_MIPS16_TLS_GOTTPREL:
6164     case R_MIPS16_TLS_LDM:
6165     case R_MICROMIPS_TLS_GD:
6166     case R_MICROMIPS_TLS_GOTTPREL:
6167     case R_MICROMIPS_TLS_LDM:
6168     case R_MICROMIPS_GOT_DISP:
6169       value = g;
6170       overflowed_p = mips_elf_overflow_p (value, 16);
6171       break;
6172
6173     case R_MIPS_GPREL32:
6174       value = (addend + symbol + gp0 - gp);
6175       if (!save_addend)
6176         value &= howto->dst_mask;
6177       break;
6178
6179     case R_MIPS_PC16:
6180     case R_MIPS_GNU_REL16_S2:
6181       if (howto->partial_inplace)
6182         addend = _bfd_mips_elf_sign_extend (addend, 18);
6183
6184       /* No need to exclude weak undefined symbols here as they resolve
6185          to 0 and never set `*cross_mode_jump_p', so this alignment check
6186          will never trigger for them.  */
6187       if (*cross_mode_jump_p
6188           ? ((symbol + addend) & 3) != 1
6189           : ((symbol + addend) & 3) != 0)
6190         return bfd_reloc_outofrange;
6191
6192       value = symbol + addend - p;
6193       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6194         overflowed_p = mips_elf_overflow_p (value, 18);
6195       value >>= howto->rightshift;
6196       value &= howto->dst_mask;
6197       break;
6198
6199     case R_MIPS16_PC16_S1:
6200       if (howto->partial_inplace)
6201         addend = _bfd_mips_elf_sign_extend (addend, 17);
6202
6203       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6204           && (*cross_mode_jump_p
6205               ? ((symbol + addend) & 3) != 0
6206               : ((symbol + addend) & 1) == 0))
6207         return bfd_reloc_outofrange;
6208
6209       value = symbol + addend - p;
6210       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6211         overflowed_p = mips_elf_overflow_p (value, 17);
6212       value >>= howto->rightshift;
6213       value &= howto->dst_mask;
6214       break;
6215
6216     case R_MIPS_PC21_S2:
6217       if (howto->partial_inplace)
6218         addend = _bfd_mips_elf_sign_extend (addend, 23);
6219
6220       if ((symbol + addend) & 3)
6221         return bfd_reloc_outofrange;
6222
6223       value = symbol + addend - p;
6224       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6225         overflowed_p = mips_elf_overflow_p (value, 23);
6226       value >>= howto->rightshift;
6227       value &= howto->dst_mask;
6228       break;
6229
6230     case R_MIPS_PC26_S2:
6231       if (howto->partial_inplace)
6232         addend = _bfd_mips_elf_sign_extend (addend, 28);
6233
6234       if ((symbol + addend) & 3)
6235         return bfd_reloc_outofrange;
6236
6237       value = symbol + addend - p;
6238       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6239         overflowed_p = mips_elf_overflow_p (value, 28);
6240       value >>= howto->rightshift;
6241       value &= howto->dst_mask;
6242       break;
6243
6244     case R_MIPS_PC18_S3:
6245       if (howto->partial_inplace)
6246         addend = _bfd_mips_elf_sign_extend (addend, 21);
6247
6248       if ((symbol + addend) & 7)
6249         return bfd_reloc_outofrange;
6250
6251       value = symbol + addend - ((p | 7) ^ 7);
6252       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6253         overflowed_p = mips_elf_overflow_p (value, 21);
6254       value >>= howto->rightshift;
6255       value &= howto->dst_mask;
6256       break;
6257
6258     case R_MIPS_PC19_S2:
6259       if (howto->partial_inplace)
6260         addend = _bfd_mips_elf_sign_extend (addend, 21);
6261
6262       if ((symbol + addend) & 3)
6263         return bfd_reloc_outofrange;
6264
6265       value = symbol + addend - p;
6266       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6267         overflowed_p = mips_elf_overflow_p (value, 21);
6268       value >>= howto->rightshift;
6269       value &= howto->dst_mask;
6270       break;
6271
6272     case R_MIPS_PCHI16:
6273       value = mips_elf_high (symbol + addend - p);
6274       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6275         overflowed_p = mips_elf_overflow_p (value, 16);
6276       value &= howto->dst_mask;
6277       break;
6278
6279     case R_MIPS_PCLO16:
6280       if (howto->partial_inplace)
6281         addend = _bfd_mips_elf_sign_extend (addend, 16);
6282       value = symbol + addend - p;
6283       value &= howto->dst_mask;
6284       break;
6285
6286     case R_MICROMIPS_PC7_S1:
6287       if (howto->partial_inplace)
6288         addend = _bfd_mips_elf_sign_extend (addend, 8);
6289
6290       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6291           && (*cross_mode_jump_p
6292               ? ((symbol + addend + 2) & 3) != 0
6293               : ((symbol + addend + 2) & 1) == 0))
6294         return bfd_reloc_outofrange;
6295
6296       value = symbol + addend - p;
6297       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6298         overflowed_p = mips_elf_overflow_p (value, 8);
6299       value >>= howto->rightshift;
6300       value &= howto->dst_mask;
6301       break;
6302
6303     case R_MICROMIPS_PC10_S1:
6304       if (howto->partial_inplace)
6305         addend = _bfd_mips_elf_sign_extend (addend, 11);
6306
6307       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6308           && (*cross_mode_jump_p
6309               ? ((symbol + addend + 2) & 3) != 0
6310               : ((symbol + addend + 2) & 1) == 0))
6311         return bfd_reloc_outofrange;
6312
6313       value = symbol + addend - p;
6314       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6315         overflowed_p = mips_elf_overflow_p (value, 11);
6316       value >>= howto->rightshift;
6317       value &= howto->dst_mask;
6318       break;
6319
6320     case R_MICROMIPS_PC16_S1:
6321       if (howto->partial_inplace)
6322         addend = _bfd_mips_elf_sign_extend (addend, 17);
6323
6324       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6325           && (*cross_mode_jump_p
6326               ? ((symbol + addend) & 3) != 0
6327               : ((symbol + addend) & 1) == 0))
6328         return bfd_reloc_outofrange;
6329
6330       value = symbol + addend - p;
6331       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6332         overflowed_p = mips_elf_overflow_p (value, 17);
6333       value >>= howto->rightshift;
6334       value &= howto->dst_mask;
6335       break;
6336
6337     case R_MICROMIPS_PC23_S2:
6338       if (howto->partial_inplace)
6339         addend = _bfd_mips_elf_sign_extend (addend, 25);
6340       value = symbol + addend - ((p | 3) ^ 3);
6341       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6342         overflowed_p = mips_elf_overflow_p (value, 25);
6343       value >>= howto->rightshift;
6344       value &= howto->dst_mask;
6345       break;
6346
6347     case R_MIPS_GOT_HI16:
6348     case R_MIPS_CALL_HI16:
6349     case R_MICROMIPS_GOT_HI16:
6350     case R_MICROMIPS_CALL_HI16:
6351       /* We're allowed to handle these two relocations identically.
6352          The dynamic linker is allowed to handle the CALL relocations
6353          differently by creating a lazy evaluation stub.  */
6354       value = g;
6355       value = mips_elf_high (value);
6356       value &= howto->dst_mask;
6357       break;
6358
6359     case R_MIPS_GOT_LO16:
6360     case R_MIPS_CALL_LO16:
6361     case R_MICROMIPS_GOT_LO16:
6362     case R_MICROMIPS_CALL_LO16:
6363       value = g & howto->dst_mask;
6364       break;
6365
6366     case R_MIPS_GOT_PAGE:
6367     case R_MICROMIPS_GOT_PAGE:
6368       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
6369       if (value == MINUS_ONE)
6370         return bfd_reloc_outofrange;
6371       value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6372       overflowed_p = mips_elf_overflow_p (value, 16);
6373       break;
6374
6375     case R_MIPS_GOT_OFST:
6376     case R_MICROMIPS_GOT_OFST:
6377       if (local_p)
6378         mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
6379       else
6380         value = addend;
6381       overflowed_p = mips_elf_overflow_p (value, 16);
6382       break;
6383
6384     case R_MIPS_SUB:
6385     case R_MICROMIPS_SUB:
6386       value = symbol - addend;
6387       value &= howto->dst_mask;
6388       break;
6389
6390     case R_MIPS_HIGHER:
6391     case R_MICROMIPS_HIGHER:
6392       value = mips_elf_higher (addend + symbol);
6393       value &= howto->dst_mask;
6394       break;
6395
6396     case R_MIPS_HIGHEST:
6397     case R_MICROMIPS_HIGHEST:
6398       value = mips_elf_highest (addend + symbol);
6399       value &= howto->dst_mask;
6400       break;
6401
6402     case R_MIPS_SCN_DISP:
6403     case R_MICROMIPS_SCN_DISP:
6404       value = symbol + addend - sec->output_offset;
6405       value &= howto->dst_mask;
6406       break;
6407
6408     case R_MIPS_JALR:
6409     case R_MICROMIPS_JALR:
6410       /* This relocation is only a hint.  In some cases, we optimize
6411          it into a bal instruction.  But we don't try to optimize
6412          when the symbol does not resolve locally.  */
6413       if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
6414         return bfd_reloc_continue;
6415       /* We can't optimize cross-mode jumps either.  */
6416       if (*cross_mode_jump_p)
6417         return bfd_reloc_continue;
6418       value = symbol + addend;
6419       /* Neither we can non-instruction-aligned targets.  */
6420       if (r_type == R_MIPS_JALR ? (value & 3) != 0 : (value & 1) == 0)
6421         return bfd_reloc_continue;
6422       break;
6423
6424     case R_MIPS_PJUMP:
6425     case R_MIPS_GNU_VTINHERIT:
6426     case R_MIPS_GNU_VTENTRY:
6427       /* We don't do anything with these at present.  */
6428       return bfd_reloc_continue;
6429
6430     default:
6431       /* An unrecognized relocation type.  */
6432       return bfd_reloc_notsupported;
6433     }
6434
6435   /* Store the VALUE for our caller.  */
6436   *valuep = value;
6437   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6438 }
6439
6440 /* It has been determined that the result of the RELOCATION is the
6441    VALUE.  Use HOWTO to place VALUE into the output file at the
6442    appropriate position.  The SECTION is the section to which the
6443    relocation applies.
6444    CROSS_MODE_JUMP_P is true if the relocation field
6445    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
6446
6447    Returns FALSE if anything goes wrong.  */
6448
6449 static bfd_boolean
6450 mips_elf_perform_relocation (struct bfd_link_info *info,
6451                              reloc_howto_type *howto,
6452                              const Elf_Internal_Rela *relocation,
6453                              bfd_vma value, bfd *input_bfd,
6454                              asection *input_section, bfd_byte *contents,
6455                              bfd_boolean cross_mode_jump_p)
6456 {
6457   bfd_vma x;
6458   bfd_byte *location;
6459   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
6460
6461   /* Figure out where the relocation is occurring.  */
6462   location = contents + relocation->r_offset;
6463
6464   _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
6465
6466   /* Obtain the current value.  */
6467   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6468
6469   /* Clear the field we are setting.  */
6470   x &= ~howto->dst_mask;
6471
6472   /* Set the field.  */
6473   x |= (value & howto->dst_mask);
6474
6475   /* Detect incorrect JALX usage.  If required, turn JAL or BAL into JALX.  */
6476   if (!cross_mode_jump_p && jal_reloc_p (r_type))
6477     {
6478       bfd_vma opcode = x >> 26;
6479
6480       if (r_type == R_MIPS16_26 ? opcode == 0x7
6481           : r_type == R_MICROMIPS_26_S1 ? opcode == 0x3c
6482           : opcode == 0x1d)
6483         {
6484           info->callbacks->einfo
6485             (_("%X%H: unsupported JALX to the same ISA mode\n"),
6486              input_bfd, input_section, relocation->r_offset);
6487           return TRUE;
6488         }
6489     }
6490   if (cross_mode_jump_p && jal_reloc_p (r_type))
6491     {
6492       bfd_boolean ok;
6493       bfd_vma opcode = x >> 26;
6494       bfd_vma jalx_opcode;
6495
6496       /* Check to see if the opcode is already JAL or JALX.  */
6497       if (r_type == R_MIPS16_26)
6498         {
6499           ok = ((opcode == 0x6) || (opcode == 0x7));
6500           jalx_opcode = 0x7;
6501         }
6502       else if (r_type == R_MICROMIPS_26_S1)
6503         {
6504           ok = ((opcode == 0x3d) || (opcode == 0x3c));
6505           jalx_opcode = 0x3c;
6506         }
6507       else
6508         {
6509           ok = ((opcode == 0x3) || (opcode == 0x1d));
6510           jalx_opcode = 0x1d;
6511         }
6512
6513       /* If the opcode is not JAL or JALX, there's a problem.  We cannot
6514          convert J or JALS to JALX.  */
6515       if (!ok)
6516         {
6517           info->callbacks->einfo
6518             (_("%X%H: unsupported jump between ISA modes; "
6519                "consider recompiling with interlinking enabled\n"),
6520              input_bfd, input_section, relocation->r_offset);
6521           return TRUE;
6522         }
6523
6524       /* Make this the JALX opcode.  */
6525       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6526     }
6527   else if (cross_mode_jump_p && b_reloc_p (r_type))
6528     {
6529       bfd_boolean ok = FALSE;
6530       bfd_vma opcode = x >> 16;
6531       bfd_vma jalx_opcode = 0;
6532       bfd_vma sign_bit = 0;
6533       bfd_vma addr;
6534       bfd_vma dest;
6535
6536       if (r_type == R_MICROMIPS_PC16_S1)
6537         {
6538           ok = opcode == 0x4060;
6539           jalx_opcode = 0x3c;
6540           sign_bit = 0x10000;
6541           value <<= 1;
6542         }
6543       else if (r_type == R_MIPS_PC16 || r_type == R_MIPS_GNU_REL16_S2)
6544         {
6545           ok = opcode == 0x411;
6546           jalx_opcode = 0x1d;
6547           sign_bit = 0x20000;
6548           value <<= 2;
6549         }
6550
6551       if (ok && !bfd_link_pic (info))
6552         {
6553           addr = (input_section->output_section->vma
6554                   + input_section->output_offset
6555                   + relocation->r_offset
6556                   + 4);
6557           dest = (addr
6558                   + (((value & ((sign_bit << 1) - 1)) ^ sign_bit) - sign_bit));
6559
6560           if ((addr >> 28) << 28 != (dest >> 28) << 28)
6561             {
6562               info->callbacks->einfo
6563                 (_("%X%H: cannot convert branch between ISA modes "
6564                    "to JALX: relocation out of range\n"),
6565                  input_bfd, input_section, relocation->r_offset);
6566               return TRUE;
6567             }
6568
6569           /* Make this the JALX opcode.  */
6570           x = ((dest >> 2) & 0x3ffffff) | jalx_opcode << 26;
6571         }
6572       else if (!mips_elf_hash_table (info)->ignore_branch_isa)
6573         {
6574           info->callbacks->einfo
6575             (_("%X%H: unsupported branch between ISA modes\n"),
6576              input_bfd, input_section, relocation->r_offset);
6577           return TRUE;
6578         }
6579     }
6580
6581   /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6582      range.  */
6583   if (!bfd_link_relocatable (info)
6584       && !cross_mode_jump_p
6585       && ((JAL_TO_BAL_P (input_bfd)
6586            && r_type == R_MIPS_26
6587            && (x >> 26) == 0x3)                 /* jal addr */
6588           || (JALR_TO_BAL_P (input_bfd)
6589               && r_type == R_MIPS_JALR
6590               && x == 0x0320f809)               /* jalr t9 */
6591           || (JR_TO_B_P (input_bfd)
6592               && r_type == R_MIPS_JALR
6593               && (x & ~1) == 0x03200008)))      /* jr t9 / jalr zero, t9 */
6594     {
6595       bfd_vma addr;
6596       bfd_vma dest;
6597       bfd_signed_vma off;
6598
6599       addr = (input_section->output_section->vma
6600               + input_section->output_offset
6601               + relocation->r_offset
6602               + 4);
6603       if (r_type == R_MIPS_26)
6604         dest = (value << 2) | ((addr >> 28) << 28);
6605       else
6606         dest = value;
6607       off = dest - addr;
6608       if (off <= 0x1ffff && off >= -0x20000)
6609         {
6610           if ((x & ~1) == 0x03200008)           /* jr t9 / jalr zero, t9 */
6611             x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff);   /* b addr */
6612           else
6613             x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
6614         }
6615     }
6616
6617   /* Put the value into the output.  */
6618   mips_elf_store_contents (howto, relocation, input_bfd, contents, x);
6619
6620   _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !bfd_link_relocatable (info),
6621                                location);
6622
6623   return TRUE;
6624 }
6625 \f
6626 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
6627    is the original relocation, which is now being transformed into a
6628    dynamic relocation.  The ADDENDP is adjusted if necessary; the
6629    caller should store the result in place of the original addend.  */
6630
6631 static bfd_boolean
6632 mips_elf_create_dynamic_relocation (bfd *output_bfd,
6633                                     struct bfd_link_info *info,
6634                                     const Elf_Internal_Rela *rel,
6635                                     struct mips_elf_link_hash_entry *h,
6636                                     asection *sec, bfd_vma symbol,
6637                                     bfd_vma *addendp, asection *input_section)
6638 {
6639   Elf_Internal_Rela outrel[3];
6640   asection *sreloc;
6641   bfd *dynobj;
6642   int r_type;
6643   long indx;
6644   bfd_boolean defined_p;
6645   struct mips_elf_link_hash_table *htab;
6646
6647   htab = mips_elf_hash_table (info);
6648   BFD_ASSERT (htab != NULL);
6649
6650   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6651   dynobj = elf_hash_table (info)->dynobj;
6652   sreloc = mips_elf_rel_dyn_section (info, FALSE);
6653   BFD_ASSERT (sreloc != NULL);
6654   BFD_ASSERT (sreloc->contents != NULL);
6655   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
6656               < sreloc->size);
6657
6658   outrel[0].r_offset =
6659     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
6660   if (ABI_64_P (output_bfd))
6661     {
6662       outrel[1].r_offset =
6663         _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6664       outrel[2].r_offset =
6665         _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6666     }
6667
6668   if (outrel[0].r_offset == MINUS_ONE)
6669     /* The relocation field has been deleted.  */
6670     return TRUE;
6671
6672   if (outrel[0].r_offset == MINUS_TWO)
6673     {
6674       /* The relocation field has been converted into a relative value of
6675          some sort.  Functions like _bfd_elf_write_section_eh_frame expect
6676          the field to be fully relocated, so add in the symbol's value.  */
6677       *addendp += symbol;
6678       return TRUE;
6679     }
6680
6681   /* We must now calculate the dynamic symbol table index to use
6682      in the relocation.  */
6683   if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6684     {
6685       BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6686       indx = h->root.dynindx;
6687       if (SGI_COMPAT (output_bfd))
6688         defined_p = h->root.def_regular;
6689       else
6690         /* ??? glibc's ld.so just adds the final GOT entry to the
6691            relocation field.  It therefore treats relocs against
6692            defined symbols in the same way as relocs against
6693            undefined symbols.  */
6694         defined_p = FALSE;
6695     }
6696   else
6697     {
6698       if (sec != NULL && bfd_is_abs_section (sec))
6699         indx = 0;
6700       else if (sec == NULL || sec->owner == NULL)
6701         {
6702           bfd_set_error (bfd_error_bad_value);
6703           return FALSE;
6704         }
6705       else
6706         {
6707           indx = elf_section_data (sec->output_section)->dynindx;
6708           if (indx == 0)
6709             {
6710               asection *osec = htab->root.text_index_section;
6711               indx = elf_section_data (osec)->dynindx;
6712             }
6713           if (indx == 0)
6714             abort ();
6715         }
6716
6717       /* Instead of generating a relocation using the section
6718          symbol, we may as well make it a fully relative
6719          relocation.  We want to avoid generating relocations to
6720          local symbols because we used to generate them
6721          incorrectly, without adding the original symbol value,
6722          which is mandated by the ABI for section symbols.  In
6723          order to give dynamic loaders and applications time to
6724          phase out the incorrect use, we refrain from emitting
6725          section-relative relocations.  It's not like they're
6726          useful, after all.  This should be a bit more efficient
6727          as well.  */
6728       /* ??? Although this behavior is compatible with glibc's ld.so,
6729          the ABI says that relocations against STN_UNDEF should have
6730          a symbol value of 0.  Irix rld honors this, so relocations
6731          against STN_UNDEF have no effect.  */
6732       if (!SGI_COMPAT (output_bfd))
6733         indx = 0;
6734       defined_p = TRUE;
6735     }
6736
6737   /* If the relocation was previously an absolute relocation and
6738      this symbol will not be referred to by the relocation, we must
6739      adjust it by the value we give it in the dynamic symbol table.
6740      Otherwise leave the job up to the dynamic linker.  */
6741   if (defined_p && r_type != R_MIPS_REL32)
6742     *addendp += symbol;
6743
6744   if (htab->is_vxworks)
6745     /* VxWorks uses non-relative relocations for this.  */
6746     outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6747   else
6748     /* The relocation is always an REL32 relocation because we don't
6749        know where the shared library will wind up at load-time.  */
6750     outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6751                                    R_MIPS_REL32);
6752
6753   /* For strict adherence to the ABI specification, we should
6754      generate a R_MIPS_64 relocation record by itself before the
6755      _REL32/_64 record as well, such that the addend is read in as
6756      a 64-bit value (REL32 is a 32-bit relocation, after all).
6757      However, since none of the existing ELF64 MIPS dynamic
6758      loaders seems to care, we don't waste space with these
6759      artificial relocations.  If this turns out to not be true,
6760      mips_elf_allocate_dynamic_relocation() should be tweaked so
6761      as to make room for a pair of dynamic relocations per
6762      invocation if ABI_64_P, and here we should generate an
6763      additional relocation record with R_MIPS_64 by itself for a
6764      NULL symbol before this relocation record.  */
6765   outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6766                                  ABI_64_P (output_bfd)
6767                                  ? R_MIPS_64
6768                                  : R_MIPS_NONE);
6769   outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6770
6771   /* Adjust the output offset of the relocation to reference the
6772      correct location in the output file.  */
6773   outrel[0].r_offset += (input_section->output_section->vma
6774                          + input_section->output_offset);
6775   outrel[1].r_offset += (input_section->output_section->vma
6776                          + input_section->output_offset);
6777   outrel[2].r_offset += (input_section->output_section->vma
6778                          + input_section->output_offset);
6779
6780   /* Put the relocation back out.  We have to use the special
6781      relocation outputter in the 64-bit case since the 64-bit
6782      relocation format is non-standard.  */
6783   if (ABI_64_P (output_bfd))
6784     {
6785       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6786         (output_bfd, &outrel[0],
6787          (sreloc->contents
6788           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6789     }
6790   else if (htab->is_vxworks)
6791     {
6792       /* VxWorks uses RELA rather than REL dynamic relocations.  */
6793       outrel[0].r_addend = *addendp;
6794       bfd_elf32_swap_reloca_out
6795         (output_bfd, &outrel[0],
6796          (sreloc->contents
6797           + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6798     }
6799   else
6800     bfd_elf32_swap_reloc_out
6801       (output_bfd, &outrel[0],
6802        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6803
6804   /* We've now added another relocation.  */
6805   ++sreloc->reloc_count;
6806
6807   /* Make sure the output section is writable.  The dynamic linker
6808      will be writing to it.  */
6809   elf_section_data (input_section->output_section)->this_hdr.sh_flags
6810     |= SHF_WRITE;
6811
6812   /* On IRIX5, make an entry of compact relocation info.  */
6813   if (IRIX_COMPAT (output_bfd) == ict_irix5)
6814     {
6815       asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6816       bfd_byte *cr;
6817
6818       if (scpt)
6819         {
6820           Elf32_crinfo cptrel;
6821
6822           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6823           cptrel.vaddr = (rel->r_offset
6824                           + input_section->output_section->vma
6825                           + input_section->output_offset);
6826           if (r_type == R_MIPS_REL32)
6827             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6828           else
6829             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6830           mips_elf_set_cr_dist2to (cptrel, 0);
6831           cptrel.konst = *addendp;
6832
6833           cr = (scpt->contents
6834                 + sizeof (Elf32_External_compact_rel));
6835           mips_elf_set_cr_relvaddr (cptrel, 0);
6836           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6837                                      ((Elf32_External_crinfo *) cr
6838                                       + scpt->reloc_count));
6839           ++scpt->reloc_count;
6840         }
6841     }
6842
6843   /* If we've written this relocation for a readonly section,
6844      we need to set DF_TEXTREL again, so that we do not delete the
6845      DT_TEXTREL tag.  */
6846   if (MIPS_ELF_READONLY_SECTION (input_section))
6847     info->flags |= DF_TEXTREL;
6848
6849   return TRUE;
6850 }
6851 \f
6852 /* Return the MACH for a MIPS e_flags value.  */
6853
6854 unsigned long
6855 _bfd_elf_mips_mach (flagword flags)
6856 {
6857   switch (flags & EF_MIPS_MACH)
6858     {
6859     case E_MIPS_MACH_3900:
6860       return bfd_mach_mips3900;
6861
6862     case E_MIPS_MACH_4010:
6863       return bfd_mach_mips4010;
6864
6865     case E_MIPS_MACH_4100:
6866       return bfd_mach_mips4100;
6867
6868     case E_MIPS_MACH_4111:
6869       return bfd_mach_mips4111;
6870
6871     case E_MIPS_MACH_4120:
6872       return bfd_mach_mips4120;
6873
6874     case E_MIPS_MACH_4650:
6875       return bfd_mach_mips4650;
6876
6877     case E_MIPS_MACH_5400:
6878       return bfd_mach_mips5400;
6879
6880     case E_MIPS_MACH_5500:
6881       return bfd_mach_mips5500;
6882
6883     case E_MIPS_MACH_5900:
6884       return bfd_mach_mips5900;
6885
6886     case E_MIPS_MACH_9000:
6887       return bfd_mach_mips9000;
6888
6889     case E_MIPS_MACH_SB1:
6890       return bfd_mach_mips_sb1;
6891
6892     case E_MIPS_MACH_LS2E:
6893       return bfd_mach_mips_loongson_2e;
6894
6895     case E_MIPS_MACH_LS2F:
6896       return bfd_mach_mips_loongson_2f;
6897
6898     case E_MIPS_MACH_GS464:
6899       return bfd_mach_mips_gs464;
6900
6901     case E_MIPS_MACH_GS464E:
6902       return bfd_mach_mips_gs464e;
6903
6904     case E_MIPS_MACH_GS264E:
6905       return bfd_mach_mips_gs264e;
6906
6907     case E_MIPS_MACH_OCTEON3:
6908       return bfd_mach_mips_octeon3;
6909
6910     case E_MIPS_MACH_OCTEON2:
6911       return bfd_mach_mips_octeon2;
6912
6913     case E_MIPS_MACH_OCTEON:
6914       return bfd_mach_mips_octeon;
6915
6916     case E_MIPS_MACH_XLR:
6917       return bfd_mach_mips_xlr;
6918
6919     case E_MIPS_MACH_IAMR2:
6920       return bfd_mach_mips_interaptiv_mr2;
6921
6922     default:
6923       switch (flags & EF_MIPS_ARCH)
6924         {
6925         default:
6926         case E_MIPS_ARCH_1:
6927           return bfd_mach_mips3000;
6928
6929         case E_MIPS_ARCH_2:
6930           return bfd_mach_mips6000;
6931
6932         case E_MIPS_ARCH_3:
6933           return bfd_mach_mips4000;
6934
6935         case E_MIPS_ARCH_4:
6936           return bfd_mach_mips8000;
6937
6938         case E_MIPS_ARCH_5:
6939           return bfd_mach_mips5;
6940
6941         case E_MIPS_ARCH_32:
6942           return bfd_mach_mipsisa32;
6943
6944         case E_MIPS_ARCH_64:
6945           return bfd_mach_mipsisa64;
6946
6947         case E_MIPS_ARCH_32R2:
6948           return bfd_mach_mipsisa32r2;
6949
6950         case E_MIPS_ARCH_64R2:
6951           return bfd_mach_mipsisa64r2;
6952
6953         case E_MIPS_ARCH_32R6:
6954           return bfd_mach_mipsisa32r6;
6955
6956         case E_MIPS_ARCH_64R6:
6957           return bfd_mach_mipsisa64r6;
6958         }
6959     }
6960
6961   return 0;
6962 }
6963
6964 /* Return printable name for ABI.  */
6965
6966 static INLINE char *
6967 elf_mips_abi_name (bfd *abfd)
6968 {
6969   flagword flags;
6970
6971   flags = elf_elfheader (abfd)->e_flags;
6972   switch (flags & EF_MIPS_ABI)
6973     {
6974     case 0:
6975       if (ABI_N32_P (abfd))
6976         return "N32";
6977       else if (ABI_64_P (abfd))
6978         return "64";
6979       else
6980         return "none";
6981     case E_MIPS_ABI_O32:
6982       return "O32";
6983     case E_MIPS_ABI_O64:
6984       return "O64";
6985     case E_MIPS_ABI_EABI32:
6986       return "EABI32";
6987     case E_MIPS_ABI_EABI64:
6988       return "EABI64";
6989     default:
6990       return "unknown abi";
6991     }
6992 }
6993 \f
6994 /* MIPS ELF uses two common sections.  One is the usual one, and the
6995    other is for small objects.  All the small objects are kept
6996    together, and then referenced via the gp pointer, which yields
6997    faster assembler code.  This is what we use for the small common
6998    section.  This approach is copied from ecoff.c.  */
6999 static asection mips_elf_scom_section;
7000 static asymbol mips_elf_scom_symbol;
7001 static asymbol *mips_elf_scom_symbol_ptr;
7002
7003 /* MIPS ELF also uses an acommon section, which represents an
7004    allocated common symbol which may be overridden by a
7005    definition in a shared library.  */
7006 static asection mips_elf_acom_section;
7007 static asymbol mips_elf_acom_symbol;
7008 static asymbol *mips_elf_acom_symbol_ptr;
7009
7010 /* This is used for both the 32-bit and the 64-bit ABI.  */
7011
7012 void
7013 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
7014 {
7015   elf_symbol_type *elfsym;
7016
7017   /* Handle the special MIPS section numbers that a symbol may use.  */
7018   elfsym = (elf_symbol_type *) asym;
7019   switch (elfsym->internal_elf_sym.st_shndx)
7020     {
7021     case SHN_MIPS_ACOMMON:
7022       /* This section is used in a dynamically linked executable file.
7023          It is an allocated common section.  The dynamic linker can
7024          either resolve these symbols to something in a shared
7025          library, or it can just leave them here.  For our purposes,
7026          we can consider these symbols to be in a new section.  */
7027       if (mips_elf_acom_section.name == NULL)
7028         {
7029           /* Initialize the acommon section.  */
7030           mips_elf_acom_section.name = ".acommon";
7031           mips_elf_acom_section.flags = SEC_ALLOC;
7032           mips_elf_acom_section.output_section = &mips_elf_acom_section;
7033           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
7034           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
7035           mips_elf_acom_symbol.name = ".acommon";
7036           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
7037           mips_elf_acom_symbol.section = &mips_elf_acom_section;
7038           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
7039         }
7040       asym->section = &mips_elf_acom_section;
7041       break;
7042
7043     case SHN_COMMON:
7044       /* Common symbols less than the GP size are automatically
7045          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
7046       if (asym->value > elf_gp_size (abfd)
7047           || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
7048           || IRIX_COMPAT (abfd) == ict_irix6)
7049         break;
7050       /* Fall through.  */
7051     case SHN_MIPS_SCOMMON:
7052       if (mips_elf_scom_section.name == NULL)
7053         {
7054           /* Initialize the small common section.  */
7055           mips_elf_scom_section.name = ".scommon";
7056           mips_elf_scom_section.flags = SEC_IS_COMMON;
7057           mips_elf_scom_section.output_section = &mips_elf_scom_section;
7058           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
7059           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
7060           mips_elf_scom_symbol.name = ".scommon";
7061           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
7062           mips_elf_scom_symbol.section = &mips_elf_scom_section;
7063           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
7064         }
7065       asym->section = &mips_elf_scom_section;
7066       asym->value = elfsym->internal_elf_sym.st_size;
7067       break;
7068
7069     case SHN_MIPS_SUNDEFINED:
7070       asym->section = bfd_und_section_ptr;
7071       break;
7072
7073     case SHN_MIPS_TEXT:
7074       {
7075         asection *section = bfd_get_section_by_name (abfd, ".text");
7076
7077         if (section != NULL)
7078           {
7079             asym->section = section;
7080             /* MIPS_TEXT is a bit special, the address is not an offset
7081                to the base of the .text section.  So subtract the section
7082                base address to make it an offset.  */
7083             asym->value -= section->vma;
7084           }
7085       }
7086       break;
7087
7088     case SHN_MIPS_DATA:
7089       {
7090         asection *section = bfd_get_section_by_name (abfd, ".data");
7091
7092         if (section != NULL)
7093           {
7094             asym->section = section;
7095             /* MIPS_DATA is a bit special, the address is not an offset
7096                to the base of the .data section.  So subtract the section
7097                base address to make it an offset.  */
7098             asym->value -= section->vma;
7099           }
7100       }
7101       break;
7102     }
7103
7104   /* If this is an odd-valued function symbol, assume it's a MIPS16
7105      or microMIPS one.  */
7106   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
7107       && (asym->value & 1) != 0)
7108     {
7109       asym->value--;
7110       if (MICROMIPS_P (abfd))
7111         elfsym->internal_elf_sym.st_other
7112           = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
7113       else
7114         elfsym->internal_elf_sym.st_other
7115           = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
7116     }
7117 }
7118 \f
7119 /* Implement elf_backend_eh_frame_address_size.  This differs from
7120    the default in the way it handles EABI64.
7121
7122    EABI64 was originally specified as an LP64 ABI, and that is what
7123    -mabi=eabi normally gives on a 64-bit target.  However, gcc has
7124    historically accepted the combination of -mabi=eabi and -mlong32,
7125    and this ILP32 variation has become semi-official over time.
7126    Both forms use elf32 and have pointer-sized FDE addresses.
7127
7128    If an EABI object was generated by GCC 4.0 or above, it will have
7129    an empty .gcc_compiled_longXX section, where XX is the size of longs
7130    in bits.  Unfortunately, ILP32 objects generated by earlier compilers
7131    have no special marking to distinguish them from LP64 objects.
7132
7133    We don't want users of the official LP64 ABI to be punished for the
7134    existence of the ILP32 variant, but at the same time, we don't want
7135    to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
7136    We therefore take the following approach:
7137
7138       - If ABFD contains a .gcc_compiled_longXX section, use it to
7139         determine the pointer size.
7140
7141       - Otherwise check the type of the first relocation.  Assume that
7142         the LP64 ABI is being used if the relocation is of type R_MIPS_64.
7143
7144       - Otherwise punt.
7145
7146    The second check is enough to detect LP64 objects generated by pre-4.0
7147    compilers because, in the kind of output generated by those compilers,
7148    the first relocation will be associated with either a CIE personality
7149    routine or an FDE start address.  Furthermore, the compilers never
7150    used a special (non-pointer) encoding for this ABI.
7151
7152    Checking the relocation type should also be safe because there is no
7153    reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
7154    did so.  */
7155
7156 unsigned int
7157 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, const asection *sec)
7158 {
7159   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
7160     return 8;
7161   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
7162     {
7163       bfd_boolean long32_p, long64_p;
7164
7165       long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
7166       long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
7167       if (long32_p && long64_p)
7168         return 0;
7169       if (long32_p)
7170         return 4;
7171       if (long64_p)
7172         return 8;
7173
7174       if (sec->reloc_count > 0
7175           && elf_section_data (sec)->relocs != NULL
7176           && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
7177               == R_MIPS_64))
7178         return 8;
7179
7180       return 0;
7181     }
7182   return 4;
7183 }
7184 \f
7185 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
7186    relocations against two unnamed section symbols to resolve to the
7187    same address.  For example, if we have code like:
7188
7189         lw      $4,%got_disp(.data)($gp)
7190         lw      $25,%got_disp(.text)($gp)
7191         jalr    $25
7192
7193    then the linker will resolve both relocations to .data and the program
7194    will jump there rather than to .text.
7195
7196    We can work around this problem by giving names to local section symbols.
7197    This is also what the MIPSpro tools do.  */
7198
7199 bfd_boolean
7200 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
7201 {
7202   return SGI_COMPAT (abfd);
7203 }
7204 \f
7205 /* Work over a section just before writing it out.  This routine is
7206    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
7207    sections that need the SHF_MIPS_GPREL flag by name; there has to be
7208    a better way.  */
7209
7210 bfd_boolean
7211 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
7212 {
7213   if (hdr->sh_type == SHT_MIPS_REGINFO
7214       && hdr->sh_size > 0)
7215     {
7216       bfd_byte buf[4];
7217
7218       BFD_ASSERT (hdr->contents == NULL);
7219
7220       if (hdr->sh_size != sizeof (Elf32_External_RegInfo))
7221         {
7222           _bfd_error_handler
7223             (_("%pB: incorrect `.reginfo' section size; "
7224                "expected %" PRIu64 ", got %" PRIu64),
7225              abfd, (uint64_t) sizeof (Elf32_External_RegInfo),
7226              (uint64_t) hdr->sh_size);
7227           bfd_set_error (bfd_error_bad_value);
7228           return FALSE;
7229         }
7230
7231       if (bfd_seek (abfd,
7232                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
7233                     SEEK_SET) != 0)
7234         return FALSE;
7235       H_PUT_32 (abfd, elf_gp (abfd), buf);
7236       if (bfd_bwrite (buf, 4, abfd) != 4)
7237         return FALSE;
7238     }
7239
7240   if (hdr->sh_type == SHT_MIPS_OPTIONS
7241       && hdr->bfd_section != NULL
7242       && mips_elf_section_data (hdr->bfd_section) != NULL
7243       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
7244     {
7245       bfd_byte *contents, *l, *lend;
7246
7247       /* We stored the section contents in the tdata field in the
7248          set_section_contents routine.  We save the section contents
7249          so that we don't have to read them again.
7250          At this point we know that elf_gp is set, so we can look
7251          through the section contents to see if there is an
7252          ODK_REGINFO structure.  */
7253
7254       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
7255       l = contents;
7256       lend = contents + hdr->sh_size;
7257       while (l + sizeof (Elf_External_Options) <= lend)
7258         {
7259           Elf_Internal_Options intopt;
7260
7261           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7262                                         &intopt);
7263           if (intopt.size < sizeof (Elf_External_Options))
7264             {
7265               _bfd_error_handler
7266                 /* xgettext:c-format */
7267                 (_("%pB: warning: bad `%s' option size %u smaller than"
7268                    " its header"),
7269                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7270               break;
7271             }
7272           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7273             {
7274               bfd_byte buf[8];
7275
7276               if (bfd_seek (abfd,
7277                             (hdr->sh_offset
7278                              + (l - contents)
7279                              + sizeof (Elf_External_Options)
7280                              + (sizeof (Elf64_External_RegInfo) - 8)),
7281                              SEEK_SET) != 0)
7282                 return FALSE;
7283               H_PUT_64 (abfd, elf_gp (abfd), buf);
7284               if (bfd_bwrite (buf, 8, abfd) != 8)
7285                 return FALSE;
7286             }
7287           else if (intopt.kind == ODK_REGINFO)
7288             {
7289               bfd_byte buf[4];
7290
7291               if (bfd_seek (abfd,
7292                             (hdr->sh_offset
7293                              + (l - contents)
7294                              + sizeof (Elf_External_Options)
7295                              + (sizeof (Elf32_External_RegInfo) - 4)),
7296                             SEEK_SET) != 0)
7297                 return FALSE;
7298               H_PUT_32 (abfd, elf_gp (abfd), buf);
7299               if (bfd_bwrite (buf, 4, abfd) != 4)
7300                 return FALSE;
7301             }
7302           l += intopt.size;
7303         }
7304     }
7305
7306   if (hdr->bfd_section != NULL)
7307     {
7308       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
7309
7310       /* .sbss is not handled specially here because the GNU/Linux
7311          prelinker can convert .sbss from NOBITS to PROGBITS and
7312          changing it back to NOBITS breaks the binary.  The entry in
7313          _bfd_mips_elf_special_sections will ensure the correct flags
7314          are set on .sbss if BFD creates it without reading it from an
7315          input file, and without special handling here the flags set
7316          on it in an input file will be followed.  */
7317       if (strcmp (name, ".sdata") == 0
7318           || strcmp (name, ".lit8") == 0
7319           || strcmp (name, ".lit4") == 0)
7320         hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7321       else if (strcmp (name, ".srdata") == 0)
7322         hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
7323       else if (strcmp (name, ".compact_rel") == 0)
7324         hdr->sh_flags = 0;
7325       else if (strcmp (name, ".rtproc") == 0)
7326         {
7327           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
7328             {
7329               unsigned int adjust;
7330
7331               adjust = hdr->sh_size % hdr->sh_addralign;
7332               if (adjust != 0)
7333                 hdr->sh_size += hdr->sh_addralign - adjust;
7334             }
7335         }
7336     }
7337
7338   return TRUE;
7339 }
7340
7341 /* Handle a MIPS specific section when reading an object file.  This
7342    is called when elfcode.h finds a section with an unknown type.
7343    This routine supports both the 32-bit and 64-bit ELF ABI.
7344
7345    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
7346    how to.  */
7347
7348 bfd_boolean
7349 _bfd_mips_elf_section_from_shdr (bfd *abfd,
7350                                  Elf_Internal_Shdr *hdr,
7351                                  const char *name,
7352                                  int shindex)
7353 {
7354   flagword flags = 0;
7355
7356   /* There ought to be a place to keep ELF backend specific flags, but
7357      at the moment there isn't one.  We just keep track of the
7358      sections by their name, instead.  Fortunately, the ABI gives
7359      suggested names for all the MIPS specific sections, so we will
7360      probably get away with this.  */
7361   switch (hdr->sh_type)
7362     {
7363     case SHT_MIPS_LIBLIST:
7364       if (strcmp (name, ".liblist") != 0)
7365         return FALSE;
7366       break;
7367     case SHT_MIPS_MSYM:
7368       if (strcmp (name, ".msym") != 0)
7369         return FALSE;
7370       break;
7371     case SHT_MIPS_CONFLICT:
7372       if (strcmp (name, ".conflict") != 0)
7373         return FALSE;
7374       break;
7375     case SHT_MIPS_GPTAB:
7376       if (! CONST_STRNEQ (name, ".gptab."))
7377         return FALSE;
7378       break;
7379     case SHT_MIPS_UCODE:
7380       if (strcmp (name, ".ucode") != 0)
7381         return FALSE;
7382       break;
7383     case SHT_MIPS_DEBUG:
7384       if (strcmp (name, ".mdebug") != 0)
7385         return FALSE;
7386       flags = SEC_DEBUGGING;
7387       break;
7388     case SHT_MIPS_REGINFO:
7389       if (strcmp (name, ".reginfo") != 0
7390           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
7391         return FALSE;
7392       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7393       break;
7394     case SHT_MIPS_IFACE:
7395       if (strcmp (name, ".MIPS.interfaces") != 0)
7396         return FALSE;
7397       break;
7398     case SHT_MIPS_CONTENT:
7399       if (! CONST_STRNEQ (name, ".MIPS.content"))
7400         return FALSE;
7401       break;
7402     case SHT_MIPS_OPTIONS:
7403       if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7404         return FALSE;
7405       break;
7406     case SHT_MIPS_ABIFLAGS:
7407       if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name))
7408         return FALSE;
7409       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7410       break;
7411     case SHT_MIPS_DWARF:
7412       if (! CONST_STRNEQ (name, ".debug_")
7413           && ! CONST_STRNEQ (name, ".zdebug_"))
7414         return FALSE;
7415       break;
7416     case SHT_MIPS_SYMBOL_LIB:
7417       if (strcmp (name, ".MIPS.symlib") != 0)
7418         return FALSE;
7419       break;
7420     case SHT_MIPS_EVENTS:
7421       if (! CONST_STRNEQ (name, ".MIPS.events")
7422           && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
7423         return FALSE;
7424       break;
7425     default:
7426       break;
7427     }
7428
7429   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7430     return FALSE;
7431
7432   if (flags)
7433     {
7434       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
7435                                    (bfd_get_section_flags (abfd,
7436                                                            hdr->bfd_section)
7437                                     | flags)))
7438         return FALSE;
7439     }
7440
7441   if (hdr->sh_type == SHT_MIPS_ABIFLAGS)
7442     {
7443       Elf_External_ABIFlags_v0 ext;
7444
7445       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7446                                       &ext, 0, sizeof ext))
7447         return FALSE;
7448       bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext,
7449                                         &mips_elf_tdata (abfd)->abiflags);
7450       if (mips_elf_tdata (abfd)->abiflags.version != 0)
7451         return FALSE;
7452       mips_elf_tdata (abfd)->abiflags_valid = TRUE;
7453     }
7454
7455   /* FIXME: We should record sh_info for a .gptab section.  */
7456
7457   /* For a .reginfo section, set the gp value in the tdata information
7458      from the contents of this section.  We need the gp value while
7459      processing relocs, so we just get it now.  The .reginfo section
7460      is not used in the 64-bit MIPS ELF ABI.  */
7461   if (hdr->sh_type == SHT_MIPS_REGINFO)
7462     {
7463       Elf32_External_RegInfo ext;
7464       Elf32_RegInfo s;
7465
7466       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7467                                       &ext, 0, sizeof ext))
7468         return FALSE;
7469       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
7470       elf_gp (abfd) = s.ri_gp_value;
7471     }
7472
7473   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7474      set the gp value based on what we find.  We may see both
7475      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7476      they should agree.  */
7477   if (hdr->sh_type == SHT_MIPS_OPTIONS)
7478     {
7479       bfd_byte *contents, *l, *lend;
7480
7481       contents = bfd_malloc (hdr->sh_size);
7482       if (contents == NULL)
7483         return FALSE;
7484       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
7485                                       0, hdr->sh_size))
7486         {
7487           free (contents);
7488           return FALSE;
7489         }
7490       l = contents;
7491       lend = contents + hdr->sh_size;
7492       while (l + sizeof (Elf_External_Options) <= lend)
7493         {
7494           Elf_Internal_Options intopt;
7495
7496           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7497                                         &intopt);
7498           if (intopt.size < sizeof (Elf_External_Options))
7499             {
7500               _bfd_error_handler
7501                 /* xgettext:c-format */
7502                 (_("%pB: warning: bad `%s' option size %u smaller than"
7503                    " its header"),
7504                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7505               break;
7506             }
7507           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7508             {
7509               Elf64_Internal_RegInfo intreg;
7510
7511               bfd_mips_elf64_swap_reginfo_in
7512                 (abfd,
7513                  ((Elf64_External_RegInfo *)
7514                   (l + sizeof (Elf_External_Options))),
7515                  &intreg);
7516               elf_gp (abfd) = intreg.ri_gp_value;
7517             }
7518           else if (intopt.kind == ODK_REGINFO)
7519             {
7520               Elf32_RegInfo intreg;
7521
7522               bfd_mips_elf32_swap_reginfo_in
7523                 (abfd,
7524                  ((Elf32_External_RegInfo *)
7525                   (l + sizeof (Elf_External_Options))),
7526                  &intreg);
7527               elf_gp (abfd) = intreg.ri_gp_value;
7528             }
7529           l += intopt.size;
7530         }
7531       free (contents);
7532     }
7533
7534   return TRUE;
7535 }
7536
7537 /* Set the correct type for a MIPS ELF section.  We do this by the
7538    section name, which is a hack, but ought to work.  This routine is
7539    used by both the 32-bit and the 64-bit ABI.  */
7540
7541 bfd_boolean
7542 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
7543 {
7544   const char *name = bfd_get_section_name (abfd, sec);
7545
7546   if (strcmp (name, ".liblist") == 0)
7547     {
7548       hdr->sh_type = SHT_MIPS_LIBLIST;
7549       hdr->sh_info = sec->size / sizeof (Elf32_Lib);
7550       /* The sh_link field is set in final_write_processing.  */
7551     }
7552   else if (strcmp (name, ".conflict") == 0)
7553     hdr->sh_type = SHT_MIPS_CONFLICT;
7554   else if (CONST_STRNEQ (name, ".gptab."))
7555     {
7556       hdr->sh_type = SHT_MIPS_GPTAB;
7557       hdr->sh_entsize = sizeof (Elf32_External_gptab);
7558       /* The sh_info field is set in final_write_processing.  */
7559     }
7560   else if (strcmp (name, ".ucode") == 0)
7561     hdr->sh_type = SHT_MIPS_UCODE;
7562   else if (strcmp (name, ".mdebug") == 0)
7563     {
7564       hdr->sh_type = SHT_MIPS_DEBUG;
7565       /* In a shared object on IRIX 5.3, the .mdebug section has an
7566          entsize of 0.  FIXME: Does this matter?  */
7567       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
7568         hdr->sh_entsize = 0;
7569       else
7570         hdr->sh_entsize = 1;
7571     }
7572   else if (strcmp (name, ".reginfo") == 0)
7573     {
7574       hdr->sh_type = SHT_MIPS_REGINFO;
7575       /* In a shared object on IRIX 5.3, the .reginfo section has an
7576          entsize of 0x18.  FIXME: Does this matter?  */
7577       if (SGI_COMPAT (abfd))
7578         {
7579           if ((abfd->flags & DYNAMIC) != 0)
7580             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7581           else
7582             hdr->sh_entsize = 1;
7583         }
7584       else
7585         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7586     }
7587   else if (SGI_COMPAT (abfd)
7588            && (strcmp (name, ".hash") == 0
7589                || strcmp (name, ".dynamic") == 0
7590                || strcmp (name, ".dynstr") == 0))
7591     {
7592       if (SGI_COMPAT (abfd))
7593         hdr->sh_entsize = 0;
7594 #if 0
7595       /* This isn't how the IRIX6 linker behaves.  */
7596       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
7597 #endif
7598     }
7599   else if (strcmp (name, ".got") == 0
7600            || strcmp (name, ".srdata") == 0
7601            || strcmp (name, ".sdata") == 0
7602            || strcmp (name, ".sbss") == 0
7603            || strcmp (name, ".lit4") == 0
7604            || strcmp (name, ".lit8") == 0)
7605     hdr->sh_flags |= SHF_MIPS_GPREL;
7606   else if (strcmp (name, ".MIPS.interfaces") == 0)
7607     {
7608       hdr->sh_type = SHT_MIPS_IFACE;
7609       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7610     }
7611   else if (CONST_STRNEQ (name, ".MIPS.content"))
7612     {
7613       hdr->sh_type = SHT_MIPS_CONTENT;
7614       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7615       /* The sh_info field is set in final_write_processing.  */
7616     }
7617   else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7618     {
7619       hdr->sh_type = SHT_MIPS_OPTIONS;
7620       hdr->sh_entsize = 1;
7621       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7622     }
7623   else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
7624     {
7625       hdr->sh_type = SHT_MIPS_ABIFLAGS;
7626       hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
7627     }
7628   else if (CONST_STRNEQ (name, ".debug_")
7629            || CONST_STRNEQ (name, ".zdebug_"))
7630     {
7631       hdr->sh_type = SHT_MIPS_DWARF;
7632
7633       /* Irix facilities such as libexc expect a single .debug_frame
7634          per executable, the system ones have NOSTRIP set and the linker
7635          doesn't merge sections with different flags so ...  */
7636       if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
7637         hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7638     }
7639   else if (strcmp (name, ".MIPS.symlib") == 0)
7640     {
7641       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
7642       /* The sh_link and sh_info fields are set in
7643          final_write_processing.  */
7644     }
7645   else if (CONST_STRNEQ (name, ".MIPS.events")
7646            || CONST_STRNEQ (name, ".MIPS.post_rel"))
7647     {
7648       hdr->sh_type = SHT_MIPS_EVENTS;
7649       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7650       /* The sh_link field is set in final_write_processing.  */
7651     }
7652   else if (strcmp (name, ".msym") == 0)
7653     {
7654       hdr->sh_type = SHT_MIPS_MSYM;
7655       hdr->sh_flags |= SHF_ALLOC;
7656       hdr->sh_entsize = 8;
7657     }
7658
7659   /* The generic elf_fake_sections will set up REL_HDR using the default
7660    kind of relocations.  We used to set up a second header for the
7661    non-default kind of relocations here, but only NewABI would use
7662    these, and the IRIX ld doesn't like resulting empty RELA sections.
7663    Thus we create those header only on demand now.  */
7664
7665   return TRUE;
7666 }
7667
7668 /* Given a BFD section, try to locate the corresponding ELF section
7669    index.  This is used by both the 32-bit and the 64-bit ABI.
7670    Actually, it's not clear to me that the 64-bit ABI supports these,
7671    but for non-PIC objects we will certainly want support for at least
7672    the .scommon section.  */
7673
7674 bfd_boolean
7675 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7676                                         asection *sec, int *retval)
7677 {
7678   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
7679     {
7680       *retval = SHN_MIPS_SCOMMON;
7681       return TRUE;
7682     }
7683   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
7684     {
7685       *retval = SHN_MIPS_ACOMMON;
7686       return TRUE;
7687     }
7688   return FALSE;
7689 }
7690 \f
7691 /* Hook called by the linker routine which adds symbols from an object
7692    file.  We must handle the special MIPS section numbers here.  */
7693
7694 bfd_boolean
7695 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
7696                                Elf_Internal_Sym *sym, const char **namep,
7697                                flagword *flagsp ATTRIBUTE_UNUSED,
7698                                asection **secp, bfd_vma *valp)
7699 {
7700   if (SGI_COMPAT (abfd)
7701       && (abfd->flags & DYNAMIC) != 0
7702       && strcmp (*namep, "_rld_new_interface") == 0)
7703     {
7704       /* Skip IRIX5 rld entry name.  */
7705       *namep = NULL;
7706       return TRUE;
7707     }
7708
7709   /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7710      a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
7711      by setting a DT_NEEDED for the shared object.  Since _gp_disp is
7712      a magic symbol resolved by the linker, we ignore this bogus definition
7713      of _gp_disp.  New ABI objects do not suffer from this problem so this
7714      is not done for them. */
7715   if (!NEWABI_P(abfd)
7716       && (sym->st_shndx == SHN_ABS)
7717       && (strcmp (*namep, "_gp_disp") == 0))
7718     {
7719       *namep = NULL;
7720       return TRUE;
7721     }
7722
7723   switch (sym->st_shndx)
7724     {
7725     case SHN_COMMON:
7726       /* Common symbols less than the GP size are automatically
7727          treated as SHN_MIPS_SCOMMON symbols.  */
7728       if (sym->st_size > elf_gp_size (abfd)
7729           || ELF_ST_TYPE (sym->st_info) == STT_TLS
7730           || IRIX_COMPAT (abfd) == ict_irix6)
7731         break;
7732       /* Fall through.  */
7733     case SHN_MIPS_SCOMMON:
7734       *secp = bfd_make_section_old_way (abfd, ".scommon");
7735       (*secp)->flags |= SEC_IS_COMMON;
7736       *valp = sym->st_size;
7737       break;
7738
7739     case SHN_MIPS_TEXT:
7740       /* This section is used in a shared object.  */
7741       if (mips_elf_tdata (abfd)->elf_text_section == NULL)
7742         {
7743           asymbol *elf_text_symbol;
7744           asection *elf_text_section;
7745           bfd_size_type amt = sizeof (asection);
7746
7747           elf_text_section = bfd_zalloc (abfd, amt);
7748           if (elf_text_section == NULL)
7749             return FALSE;
7750
7751           amt = sizeof (asymbol);
7752           elf_text_symbol = bfd_zalloc (abfd, amt);
7753           if (elf_text_symbol == NULL)
7754             return FALSE;
7755
7756           /* Initialize the section.  */
7757
7758           mips_elf_tdata (abfd)->elf_text_section = elf_text_section;
7759           mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7760
7761           elf_text_section->symbol = elf_text_symbol;
7762           elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol;
7763
7764           elf_text_section->name = ".text";
7765           elf_text_section->flags = SEC_NO_FLAGS;
7766           elf_text_section->output_section = NULL;
7767           elf_text_section->owner = abfd;
7768           elf_text_symbol->name = ".text";
7769           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7770           elf_text_symbol->section = elf_text_section;
7771         }
7772       /* This code used to do *secp = bfd_und_section_ptr if
7773          bfd_link_pic (info).  I don't know why, and that doesn't make sense,
7774          so I took it out.  */
7775       *secp = mips_elf_tdata (abfd)->elf_text_section;
7776       break;
7777
7778     case SHN_MIPS_ACOMMON:
7779       /* Fall through. XXX Can we treat this as allocated data?  */
7780     case SHN_MIPS_DATA:
7781       /* This section is used in a shared object.  */
7782       if (mips_elf_tdata (abfd)->elf_data_section == NULL)
7783         {
7784           asymbol *elf_data_symbol;
7785           asection *elf_data_section;
7786           bfd_size_type amt = sizeof (asection);
7787
7788           elf_data_section = bfd_zalloc (abfd, amt);
7789           if (elf_data_section == NULL)
7790             return FALSE;
7791
7792           amt = sizeof (asymbol);
7793           elf_data_symbol = bfd_zalloc (abfd, amt);
7794           if (elf_data_symbol == NULL)
7795             return FALSE;
7796
7797           /* Initialize the section.  */
7798
7799           mips_elf_tdata (abfd)->elf_data_section = elf_data_section;
7800           mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7801
7802           elf_data_section->symbol = elf_data_symbol;
7803           elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol;
7804
7805           elf_data_section->name = ".data";
7806           elf_data_section->flags = SEC_NO_FLAGS;
7807           elf_data_section->output_section = NULL;
7808           elf_data_section->owner = abfd;
7809           elf_data_symbol->name = ".data";
7810           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7811           elf_data_symbol->section = elf_data_section;
7812         }
7813       /* This code used to do *secp = bfd_und_section_ptr if
7814          bfd_link_pic (info).  I don't know why, and that doesn't make sense,
7815          so I took it out.  */
7816       *secp = mips_elf_tdata (abfd)->elf_data_section;
7817       break;
7818
7819     case SHN_MIPS_SUNDEFINED:
7820       *secp = bfd_und_section_ptr;
7821       break;
7822     }
7823
7824   if (SGI_COMPAT (abfd)
7825       && ! bfd_link_pic (info)
7826       && info->output_bfd->xvec == abfd->xvec
7827       && strcmp (*namep, "__rld_obj_head") == 0)
7828     {
7829       struct elf_link_hash_entry *h;
7830       struct bfd_link_hash_entry *bh;
7831
7832       /* Mark __rld_obj_head as dynamic.  */
7833       bh = NULL;
7834       if (! (_bfd_generic_link_add_one_symbol
7835              (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7836               get_elf_backend_data (abfd)->collect, &bh)))
7837         return FALSE;
7838
7839       h = (struct elf_link_hash_entry *) bh;
7840       h->non_elf = 0;
7841       h->def_regular = 1;
7842       h->type = STT_OBJECT;
7843
7844       if (! bfd_elf_link_record_dynamic_symbol (info, h))
7845         return FALSE;
7846
7847       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7848       mips_elf_hash_table (info)->rld_symbol = h;
7849     }
7850
7851   /* If this is a mips16 text symbol, add 1 to the value to make it
7852      odd.  This will cause something like .word SYM to come up with
7853      the right value when it is loaded into the PC.  */
7854   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7855     ++*valp;
7856
7857   return TRUE;
7858 }
7859
7860 /* This hook function is called before the linker writes out a global
7861    symbol.  We mark symbols as small common if appropriate.  This is
7862    also where we undo the increment of the value for a mips16 symbol.  */
7863
7864 int
7865 _bfd_mips_elf_link_output_symbol_hook
7866   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7867    const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7868    asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7869 {
7870   /* If we see a common symbol, which implies a relocatable link, then
7871      if a symbol was small common in an input file, mark it as small
7872      common in the output file.  */
7873   if (sym->st_shndx == SHN_COMMON
7874       && strcmp (input_sec->name, ".scommon") == 0)
7875     sym->st_shndx = SHN_MIPS_SCOMMON;
7876
7877   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7878     sym->st_value &= ~1;
7879
7880   return 1;
7881 }
7882 \f
7883 /* Functions for the dynamic linker.  */
7884
7885 /* Create dynamic sections when linking against a dynamic object.  */
7886
7887 bfd_boolean
7888 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7889 {
7890   struct elf_link_hash_entry *h;
7891   struct bfd_link_hash_entry *bh;
7892   flagword flags;
7893   register asection *s;
7894   const char * const *namep;
7895   struct mips_elf_link_hash_table *htab;
7896
7897   htab = mips_elf_hash_table (info);
7898   BFD_ASSERT (htab != NULL);
7899
7900   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7901            | SEC_LINKER_CREATED | SEC_READONLY);
7902
7903   /* The psABI requires a read-only .dynamic section, but the VxWorks
7904      EABI doesn't.  */
7905   if (!htab->is_vxworks)
7906     {
7907       s = bfd_get_linker_section (abfd, ".dynamic");
7908       if (s != NULL)
7909         {
7910           if (! bfd_set_section_flags (abfd, s, flags))
7911             return FALSE;
7912         }
7913     }
7914
7915   /* We need to create .got section.  */
7916   if (!mips_elf_create_got_section (abfd, info))
7917     return FALSE;
7918
7919   if (! mips_elf_rel_dyn_section (info, TRUE))
7920     return FALSE;
7921
7922   /* Create .stub section.  */
7923   s = bfd_make_section_anyway_with_flags (abfd,
7924                                           MIPS_ELF_STUB_SECTION_NAME (abfd),
7925                                           flags | SEC_CODE);
7926   if (s == NULL
7927       || ! bfd_set_section_alignment (abfd, s,
7928                                       MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7929     return FALSE;
7930   htab->sstubs = s;
7931
7932   if (!mips_elf_hash_table (info)->use_rld_obj_head
7933       && bfd_link_executable (info)
7934       && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7935     {
7936       s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7937                                               flags &~ (flagword) SEC_READONLY);
7938       if (s == NULL
7939           || ! bfd_set_section_alignment (abfd, s,
7940                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7941         return FALSE;
7942     }
7943
7944   /* On IRIX5, we adjust add some additional symbols and change the
7945      alignments of several sections.  There is no ABI documentation
7946      indicating that this is necessary on IRIX6, nor any evidence that
7947      the linker takes such action.  */
7948   if (IRIX_COMPAT (abfd) == ict_irix5)
7949     {
7950       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7951         {
7952           bh = NULL;
7953           if (! (_bfd_generic_link_add_one_symbol
7954                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7955                   NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7956             return FALSE;
7957
7958           h = (struct elf_link_hash_entry *) bh;
7959           h->mark = 1;
7960           h->non_elf = 0;
7961           h->def_regular = 1;
7962           h->type = STT_SECTION;
7963
7964           if (! bfd_elf_link_record_dynamic_symbol (info, h))
7965             return FALSE;
7966         }
7967
7968       /* We need to create a .compact_rel section.  */
7969       if (SGI_COMPAT (abfd))
7970         {
7971           if (!mips_elf_create_compact_rel_section (abfd, info))
7972             return FALSE;
7973         }
7974
7975       /* Change alignments of some sections.  */
7976       s = bfd_get_linker_section (abfd, ".hash");
7977       if (s != NULL)
7978         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7979
7980       s = bfd_get_linker_section (abfd, ".dynsym");
7981       if (s != NULL)
7982         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7983
7984       s = bfd_get_linker_section (abfd, ".dynstr");
7985       if (s != NULL)
7986         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7987
7988       /* ??? */
7989       s = bfd_get_section_by_name (abfd, ".reginfo");
7990       if (s != NULL)
7991         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7992
7993       s = bfd_get_linker_section (abfd, ".dynamic");
7994       if (s != NULL)
7995         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7996     }
7997
7998   if (bfd_link_executable (info))
7999     {
8000       const char *name;
8001
8002       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
8003       bh = NULL;
8004       if (!(_bfd_generic_link_add_one_symbol
8005             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
8006              NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
8007         return FALSE;
8008
8009       h = (struct elf_link_hash_entry *) bh;
8010       h->non_elf = 0;
8011       h->def_regular = 1;
8012       h->type = STT_SECTION;
8013
8014       if (! bfd_elf_link_record_dynamic_symbol (info, h))
8015         return FALSE;
8016
8017       if (! mips_elf_hash_table (info)->use_rld_obj_head)
8018         {
8019           /* __rld_map is a four byte word located in the .data section
8020              and is filled in by the rtld to contain a pointer to
8021              the _r_debug structure. Its symbol value will be set in
8022              _bfd_mips_elf_finish_dynamic_symbol.  */
8023           s = bfd_get_linker_section (abfd, ".rld_map");
8024           BFD_ASSERT (s != NULL);
8025
8026           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
8027           bh = NULL;
8028           if (!(_bfd_generic_link_add_one_symbol
8029                 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
8030                  get_elf_backend_data (abfd)->collect, &bh)))
8031             return FALSE;
8032
8033           h = (struct elf_link_hash_entry *) bh;
8034           h->non_elf = 0;
8035           h->def_regular = 1;
8036           h->type = STT_OBJECT;
8037
8038           if (! bfd_elf_link_record_dynamic_symbol (info, h))
8039             return FALSE;
8040           mips_elf_hash_table (info)->rld_symbol = h;
8041         }
8042     }
8043
8044   /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
8045      Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol.  */
8046   if (!_bfd_elf_create_dynamic_sections (abfd, info))
8047     return FALSE;
8048
8049   /* Do the usual VxWorks handling.  */
8050   if (htab->is_vxworks
8051       && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
8052     return FALSE;
8053
8054   return TRUE;
8055 }
8056 \f
8057 /* Return true if relocation REL against section SEC is a REL rather than
8058    RELA relocation.  RELOCS is the first relocation in the section and
8059    ABFD is the bfd that contains SEC.  */
8060
8061 static bfd_boolean
8062 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
8063                            const Elf_Internal_Rela *relocs,
8064                            const Elf_Internal_Rela *rel)
8065 {
8066   Elf_Internal_Shdr *rel_hdr;
8067   const struct elf_backend_data *bed;
8068
8069   /* To determine which flavor of relocation this is, we depend on the
8070      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
8071   rel_hdr = elf_section_data (sec)->rel.hdr;
8072   if (rel_hdr == NULL)
8073     return FALSE;
8074   bed = get_elf_backend_data (abfd);
8075   return ((size_t) (rel - relocs)
8076           < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
8077 }
8078
8079 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
8080    HOWTO is the relocation's howto and CONTENTS points to the contents
8081    of the section that REL is against.  */
8082
8083 static bfd_vma
8084 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
8085                           reloc_howto_type *howto, bfd_byte *contents)
8086 {
8087   bfd_byte *location;
8088   unsigned int r_type;
8089   bfd_vma addend;
8090   bfd_vma bytes;
8091
8092   r_type = ELF_R_TYPE (abfd, rel->r_info);
8093   location = contents + rel->r_offset;
8094
8095   /* Get the addend, which is stored in the input file.  */
8096   _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
8097   bytes = mips_elf_obtain_contents (howto, rel, abfd, contents);
8098   _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
8099
8100   addend = bytes & howto->src_mask;
8101
8102   /* Shift is 2, unusually, for microMIPS JALX.  Adjust the addend
8103      accordingly.  */
8104   if (r_type == R_MICROMIPS_26_S1 && (bytes >> 26) == 0x3c)
8105     addend <<= 1;
8106
8107   return addend;
8108 }
8109
8110 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
8111    and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
8112    and update *ADDEND with the final addend.  Return true on success
8113    or false if the LO16 could not be found.  RELEND is the exclusive
8114    upper bound on the relocations for REL's section.  */
8115
8116 static bfd_boolean
8117 mips_elf_add_lo16_rel_addend (bfd *abfd,
8118                               const Elf_Internal_Rela *rel,
8119                               const Elf_Internal_Rela *relend,
8120                               bfd_byte *contents, bfd_vma *addend)
8121 {
8122   unsigned int r_type, lo16_type;
8123   const Elf_Internal_Rela *lo16_relocation;
8124   reloc_howto_type *lo16_howto;
8125   bfd_vma l;
8126
8127   r_type = ELF_R_TYPE (abfd, rel->r_info);
8128   if (mips16_reloc_p (r_type))
8129     lo16_type = R_MIPS16_LO16;
8130   else if (micromips_reloc_p (r_type))
8131     lo16_type = R_MICROMIPS_LO16;
8132   else if (r_type == R_MIPS_PCHI16)
8133     lo16_type = R_MIPS_PCLO16;
8134   else
8135     lo16_type = R_MIPS_LO16;
8136
8137   /* The combined value is the sum of the HI16 addend, left-shifted by
8138      sixteen bits, and the LO16 addend, sign extended.  (Usually, the
8139      code does a `lui' of the HI16 value, and then an `addiu' of the
8140      LO16 value.)
8141
8142      Scan ahead to find a matching LO16 relocation.
8143
8144      According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8145      be immediately following.  However, for the IRIX6 ABI, the next
8146      relocation may be a composed relocation consisting of several
8147      relocations for the same address.  In that case, the R_MIPS_LO16
8148      relocation may occur as one of these.  We permit a similar
8149      extension in general, as that is useful for GCC.
8150
8151      In some cases GCC dead code elimination removes the LO16 but keeps
8152      the corresponding HI16.  This is strictly speaking a violation of
8153      the ABI but not immediately harmful.  */
8154   lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
8155   if (lo16_relocation == NULL)
8156     return FALSE;
8157
8158   /* Obtain the addend kept there.  */
8159   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
8160   l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
8161
8162   l <<= lo16_howto->rightshift;
8163   l = _bfd_mips_elf_sign_extend (l, 16);
8164
8165   *addend <<= 16;
8166   *addend += l;
8167   return TRUE;
8168 }
8169
8170 /* Try to read the contents of section SEC in bfd ABFD.  Return true and
8171    store the contents in *CONTENTS on success.  Assume that *CONTENTS
8172    already holds the contents if it is nonull on entry.  */
8173
8174 static bfd_boolean
8175 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
8176 {
8177   if (*contents)
8178     return TRUE;
8179
8180   /* Get cached copy if it exists.  */
8181   if (elf_section_data (sec)->this_hdr.contents != NULL)
8182     {
8183       *contents = elf_section_data (sec)->this_hdr.contents;
8184       return TRUE;
8185     }
8186
8187   return bfd_malloc_and_get_section (abfd, sec, contents);
8188 }
8189
8190 /* Make a new PLT record to keep internal data.  */
8191
8192 static struct plt_entry *
8193 mips_elf_make_plt_record (bfd *abfd)
8194 {
8195   struct plt_entry *entry;
8196
8197   entry = bfd_zalloc (abfd, sizeof (*entry));
8198   if (entry == NULL)
8199     return NULL;
8200
8201   entry->stub_offset = MINUS_ONE;
8202   entry->mips_offset = MINUS_ONE;
8203   entry->comp_offset = MINUS_ONE;
8204   entry->gotplt_index = MINUS_ONE;
8205   return entry;
8206 }
8207
8208 /* Define the special `__gnu_absolute_zero' symbol.  We only need this
8209    for PIC code, as otherwise there is no load-time relocation involved
8210    and local GOT entries whose value is zero at static link time will
8211    retain their value at load time.  */
8212
8213 static bfd_boolean
8214 mips_elf_define_absolute_zero (bfd *abfd, struct bfd_link_info *info,
8215                                struct mips_elf_link_hash_table *htab,
8216                                unsigned int r_type)
8217 {
8218   union
8219     {
8220       struct elf_link_hash_entry *eh;
8221       struct bfd_link_hash_entry *bh;
8222     }
8223   hzero;
8224
8225   BFD_ASSERT (!htab->use_absolute_zero);
8226   BFD_ASSERT (bfd_link_pic (info));
8227
8228   hzero.bh = NULL;
8229   if (!_bfd_generic_link_add_one_symbol (info, abfd, "__gnu_absolute_zero",
8230                                          BSF_GLOBAL, bfd_abs_section_ptr, 0,
8231                                          NULL, FALSE, FALSE, &hzero.bh))
8232     return FALSE;
8233
8234   BFD_ASSERT (hzero.bh != NULL);
8235   hzero.eh->size = 0;
8236   hzero.eh->type = STT_NOTYPE;
8237   hzero.eh->other = STV_PROTECTED;
8238   hzero.eh->def_regular = 1;
8239   hzero.eh->non_elf = 0;
8240
8241   if (!mips_elf_record_global_got_symbol (hzero.eh, abfd, info, TRUE, r_type))
8242     return FALSE;
8243
8244   htab->use_absolute_zero = TRUE;
8245
8246   return TRUE;
8247 }
8248
8249 /* Look through the relocs for a section during the first phase, and
8250    allocate space in the global offset table and record the need for
8251    standard MIPS and compressed procedure linkage table entries.  */
8252
8253 bfd_boolean
8254 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
8255                             asection *sec, const Elf_Internal_Rela *relocs)
8256 {
8257   const char *name;
8258   bfd *dynobj;
8259   Elf_Internal_Shdr *symtab_hdr;
8260   struct elf_link_hash_entry **sym_hashes;
8261   size_t extsymoff;
8262   const Elf_Internal_Rela *rel;
8263   const Elf_Internal_Rela *rel_end;
8264   asection *sreloc;
8265   const struct elf_backend_data *bed;
8266   struct mips_elf_link_hash_table *htab;
8267   bfd_byte *contents;
8268   bfd_vma addend;
8269   reloc_howto_type *howto;
8270
8271   if (bfd_link_relocatable (info))
8272     return TRUE;
8273
8274   htab = mips_elf_hash_table (info);
8275   BFD_ASSERT (htab != NULL);
8276
8277   dynobj = elf_hash_table (info)->dynobj;
8278   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8279   sym_hashes = elf_sym_hashes (abfd);
8280   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8281
8282   bed = get_elf_backend_data (abfd);
8283   rel_end = relocs + sec->reloc_count;
8284
8285   /* Check for the mips16 stub sections.  */
8286
8287   name = bfd_get_section_name (abfd, sec);
8288   if (FN_STUB_P (name))
8289     {
8290       unsigned long r_symndx;
8291
8292       /* Look at the relocation information to figure out which symbol
8293          this is for.  */
8294
8295       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8296       if (r_symndx == 0)
8297         {
8298           _bfd_error_handler
8299             /* xgettext:c-format */
8300             (_("%pB: warning: cannot determine the target function for"
8301                " stub section `%s'"),
8302              abfd, name);
8303           bfd_set_error (bfd_error_bad_value);
8304           return FALSE;
8305         }
8306
8307       if (r_symndx < extsymoff
8308           || sym_hashes[r_symndx - extsymoff] == NULL)
8309         {
8310           asection *o;
8311
8312           /* This stub is for a local symbol.  This stub will only be
8313              needed if there is some relocation in this BFD, other
8314              than a 16 bit function call, which refers to this symbol.  */
8315           for (o = abfd->sections; o != NULL; o = o->next)
8316             {
8317               Elf_Internal_Rela *sec_relocs;
8318               const Elf_Internal_Rela *r, *rend;
8319
8320               /* We can ignore stub sections when looking for relocs.  */
8321               if ((o->flags & SEC_RELOC) == 0
8322                   || o->reloc_count == 0
8323                   || section_allows_mips16_refs_p (o))
8324                 continue;
8325
8326               sec_relocs
8327                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8328                                              info->keep_memory);
8329               if (sec_relocs == NULL)
8330                 return FALSE;
8331
8332               rend = sec_relocs + o->reloc_count;
8333               for (r = sec_relocs; r < rend; r++)
8334                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8335                     && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
8336                   break;
8337
8338               if (elf_section_data (o)->relocs != sec_relocs)
8339                 free (sec_relocs);
8340
8341               if (r < rend)
8342                 break;
8343             }
8344
8345           if (o == NULL)
8346             {
8347               /* There is no non-call reloc for this stub, so we do
8348                  not need it.  Since this function is called before
8349                  the linker maps input sections to output sections, we
8350                  can easily discard it by setting the SEC_EXCLUDE
8351                  flag.  */
8352               sec->flags |= SEC_EXCLUDE;
8353               return TRUE;
8354             }
8355
8356           /* Record this stub in an array of local symbol stubs for
8357              this BFD.  */
8358           if (mips_elf_tdata (abfd)->local_stubs == NULL)
8359             {
8360               unsigned long symcount;
8361               asection **n;
8362               bfd_size_type amt;
8363
8364               if (elf_bad_symtab (abfd))
8365                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8366               else
8367                 symcount = symtab_hdr->sh_info;
8368               amt = symcount * sizeof (asection *);
8369               n = bfd_zalloc (abfd, amt);
8370               if (n == NULL)
8371                 return FALSE;
8372               mips_elf_tdata (abfd)->local_stubs = n;
8373             }
8374
8375           sec->flags |= SEC_KEEP;
8376           mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec;
8377
8378           /* We don't need to set mips16_stubs_seen in this case.
8379              That flag is used to see whether we need to look through
8380              the global symbol table for stubs.  We don't need to set
8381              it here, because we just have a local stub.  */
8382         }
8383       else
8384         {
8385           struct mips_elf_link_hash_entry *h;
8386
8387           h = ((struct mips_elf_link_hash_entry *)
8388                sym_hashes[r_symndx - extsymoff]);
8389
8390           while (h->root.root.type == bfd_link_hash_indirect
8391                  || h->root.root.type == bfd_link_hash_warning)
8392             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8393
8394           /* H is the symbol this stub is for.  */
8395
8396           /* If we already have an appropriate stub for this function, we
8397              don't need another one, so we can discard this one.  Since
8398              this function is called before the linker maps input sections
8399              to output sections, we can easily discard it by setting the
8400              SEC_EXCLUDE flag.  */
8401           if (h->fn_stub != NULL)
8402             {
8403               sec->flags |= SEC_EXCLUDE;
8404               return TRUE;
8405             }
8406
8407           sec->flags |= SEC_KEEP;
8408           h->fn_stub = sec;
8409           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8410         }
8411     }
8412   else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
8413     {
8414       unsigned long r_symndx;
8415       struct mips_elf_link_hash_entry *h;
8416       asection **loc;
8417
8418       /* Look at the relocation information to figure out which symbol
8419          this is for.  */
8420
8421       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8422       if (r_symndx == 0)
8423         {
8424           _bfd_error_handler
8425             /* xgettext:c-format */
8426             (_("%pB: warning: cannot determine the target function for"
8427                " stub section `%s'"),
8428              abfd, name);
8429           bfd_set_error (bfd_error_bad_value);
8430           return FALSE;
8431         }
8432
8433       if (r_symndx < extsymoff
8434           || sym_hashes[r_symndx - extsymoff] == NULL)
8435         {
8436           asection *o;
8437
8438           /* This stub is for a local symbol.  This stub will only be
8439              needed if there is some relocation (R_MIPS16_26) in this BFD
8440              that refers to this symbol.  */
8441           for (o = abfd->sections; o != NULL; o = o->next)
8442             {
8443               Elf_Internal_Rela *sec_relocs;
8444               const Elf_Internal_Rela *r, *rend;
8445
8446               /* We can ignore stub sections when looking for relocs.  */
8447               if ((o->flags & SEC_RELOC) == 0
8448                   || o->reloc_count == 0
8449                   || section_allows_mips16_refs_p (o))
8450                 continue;
8451
8452               sec_relocs
8453                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8454                                              info->keep_memory);
8455               if (sec_relocs == NULL)
8456                 return FALSE;
8457
8458               rend = sec_relocs + o->reloc_count;
8459               for (r = sec_relocs; r < rend; r++)
8460                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8461                     && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
8462                     break;
8463
8464               if (elf_section_data (o)->relocs != sec_relocs)
8465                 free (sec_relocs);
8466
8467               if (r < rend)
8468                 break;
8469             }
8470
8471           if (o == NULL)
8472             {
8473               /* There is no non-call reloc for this stub, so we do
8474                  not need it.  Since this function is called before
8475                  the linker maps input sections to output sections, we
8476                  can easily discard it by setting the SEC_EXCLUDE
8477                  flag.  */
8478               sec->flags |= SEC_EXCLUDE;
8479               return TRUE;
8480             }
8481
8482           /* Record this stub in an array of local symbol call_stubs for
8483              this BFD.  */
8484           if (mips_elf_tdata (abfd)->local_call_stubs == NULL)
8485             {
8486               unsigned long symcount;
8487               asection **n;
8488               bfd_size_type amt;
8489
8490               if (elf_bad_symtab (abfd))
8491                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8492               else
8493                 symcount = symtab_hdr->sh_info;
8494               amt = symcount * sizeof (asection *);
8495               n = bfd_zalloc (abfd, amt);
8496               if (n == NULL)
8497                 return FALSE;
8498               mips_elf_tdata (abfd)->local_call_stubs = n;
8499             }
8500
8501           sec->flags |= SEC_KEEP;
8502           mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
8503
8504           /* We don't need to set mips16_stubs_seen in this case.
8505              That flag is used to see whether we need to look through
8506              the global symbol table for stubs.  We don't need to set
8507              it here, because we just have a local stub.  */
8508         }
8509       else
8510         {
8511           h = ((struct mips_elf_link_hash_entry *)
8512                sym_hashes[r_symndx - extsymoff]);
8513
8514           /* H is the symbol this stub is for.  */
8515
8516           if (CALL_FP_STUB_P (name))
8517             loc = &h->call_fp_stub;
8518           else
8519             loc = &h->call_stub;
8520
8521           /* If we already have an appropriate stub for this function, we
8522              don't need another one, so we can discard this one.  Since
8523              this function is called before the linker maps input sections
8524              to output sections, we can easily discard it by setting the
8525              SEC_EXCLUDE flag.  */
8526           if (*loc != NULL)
8527             {
8528               sec->flags |= SEC_EXCLUDE;
8529               return TRUE;
8530             }
8531
8532           sec->flags |= SEC_KEEP;
8533           *loc = sec;
8534           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8535         }
8536     }
8537
8538   sreloc = NULL;
8539   contents = NULL;
8540   for (rel = relocs; rel < rel_end; ++rel)
8541     {
8542       unsigned long r_symndx;
8543       unsigned int r_type;
8544       struct elf_link_hash_entry *h;
8545       bfd_boolean can_make_dynamic_p;
8546       bfd_boolean call_reloc_p;
8547       bfd_boolean constrain_symbol_p;
8548
8549       r_symndx = ELF_R_SYM (abfd, rel->r_info);
8550       r_type = ELF_R_TYPE (abfd, rel->r_info);
8551
8552       if (r_symndx < extsymoff)
8553         h = NULL;
8554       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
8555         {
8556           _bfd_error_handler
8557             /* xgettext:c-format */
8558             (_("%pB: malformed reloc detected for section %s"),
8559              abfd, name);
8560           bfd_set_error (bfd_error_bad_value);
8561           return FALSE;
8562         }
8563       else
8564         {
8565           h = sym_hashes[r_symndx - extsymoff];
8566           if (h != NULL)
8567             {
8568               while (h->root.type == bfd_link_hash_indirect
8569                      || h->root.type == bfd_link_hash_warning)
8570                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8571             }
8572         }
8573
8574       /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8575          relocation into a dynamic one.  */
8576       can_make_dynamic_p = FALSE;
8577
8578       /* Set CALL_RELOC_P to true if the relocation is for a call,
8579          and if pointer equality therefore doesn't matter.  */
8580       call_reloc_p = FALSE;
8581
8582       /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8583          into account when deciding how to define the symbol.
8584          Relocations in nonallocatable sections such as .pdr and
8585          .debug* should have no effect.  */
8586       constrain_symbol_p = ((sec->flags & SEC_ALLOC) != 0);
8587
8588       switch (r_type)
8589         {
8590         case R_MIPS_CALL16:
8591         case R_MIPS_CALL_HI16:
8592         case R_MIPS_CALL_LO16:
8593         case R_MIPS16_CALL16:
8594         case R_MICROMIPS_CALL16:
8595         case R_MICROMIPS_CALL_HI16:
8596         case R_MICROMIPS_CALL_LO16:
8597           call_reloc_p = TRUE;
8598           /* Fall through.  */
8599
8600         case R_MIPS_GOT16:
8601         case R_MIPS_GOT_LO16:
8602         case R_MIPS_GOT_PAGE:
8603         case R_MIPS_GOT_DISP:
8604         case R_MIPS16_GOT16:
8605         case R_MICROMIPS_GOT16:
8606         case R_MICROMIPS_GOT_LO16:
8607         case R_MICROMIPS_GOT_PAGE:
8608         case R_MICROMIPS_GOT_DISP:
8609           /* If we have a symbol that will resolve to zero at static link
8610              time and it is used by a GOT relocation applied to code we
8611              cannot relax to an immediate zero load, then we will be using
8612              the special `__gnu_absolute_zero' symbol whose value is zero
8613              at dynamic load time.  We ignore HI16-type GOT relocations at
8614              this stage, because their handling will depend entirely on
8615              the corresponding LO16-type GOT relocation.  */
8616           if (!call_hi16_reloc_p (r_type)
8617               && h != NULL
8618               && bfd_link_pic (info)
8619               && !htab->use_absolute_zero
8620               && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
8621             {
8622               bfd_boolean rel_reloc;
8623
8624               if (!mips_elf_get_section_contents (abfd, sec, &contents))
8625                 return FALSE;
8626
8627               rel_reloc = mips_elf_rel_relocation_p (abfd, sec, relocs, rel);
8628               howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, !rel_reloc);
8629
8630               if (!mips_elf_nullify_got_load (abfd, contents, rel, howto,
8631                                               FALSE))
8632                 if (!mips_elf_define_absolute_zero (abfd, info, htab, r_type))
8633                   return FALSE;
8634             }
8635
8636           /* Fall through.  */
8637         case R_MIPS_GOT_HI16:
8638         case R_MIPS_GOT_OFST:
8639         case R_MIPS_TLS_GOTTPREL:
8640         case R_MIPS_TLS_GD:
8641         case R_MIPS_TLS_LDM:
8642         case R_MIPS16_TLS_GOTTPREL:
8643         case R_MIPS16_TLS_GD:
8644         case R_MIPS16_TLS_LDM:
8645         case R_MICROMIPS_GOT_HI16:
8646         case R_MICROMIPS_GOT_OFST:
8647         case R_MICROMIPS_TLS_GOTTPREL:
8648         case R_MICROMIPS_TLS_GD:
8649         case R_MICROMIPS_TLS_LDM:
8650           if (dynobj == NULL)
8651             elf_hash_table (info)->dynobj = dynobj = abfd;
8652           if (!mips_elf_create_got_section (dynobj, info))
8653             return FALSE;
8654           if (htab->is_vxworks && !bfd_link_pic (info))
8655             {
8656               _bfd_error_handler
8657                 /* xgettext:c-format */
8658                 (_("%pB: GOT reloc at %#" PRIx64 " not expected in executables"),
8659                  abfd, (uint64_t) rel->r_offset);
8660               bfd_set_error (bfd_error_bad_value);
8661               return FALSE;
8662             }
8663           can_make_dynamic_p = TRUE;
8664           break;
8665
8666         case R_MIPS_NONE:
8667         case R_MIPS_JALR:
8668         case R_MICROMIPS_JALR:
8669           /* These relocations have empty fields and are purely there to
8670              provide link information.  The symbol value doesn't matter.  */
8671           constrain_symbol_p = FALSE;
8672           break;
8673
8674         case R_MIPS_GPREL16:
8675         case R_MIPS_GPREL32:
8676         case R_MIPS16_GPREL:
8677         case R_MICROMIPS_GPREL16:
8678           /* GP-relative relocations always resolve to a definition in a
8679              regular input file, ignoring the one-definition rule.  This is
8680              important for the GP setup sequence in NewABI code, which
8681              always resolves to a local function even if other relocations
8682              against the symbol wouldn't.  */
8683           constrain_symbol_p = FALSE;
8684           break;
8685
8686         case R_MIPS_32:
8687         case R_MIPS_REL32:
8688         case R_MIPS_64:
8689           /* In VxWorks executables, references to external symbols
8690              must be handled using copy relocs or PLT entries; it is not
8691              possible to convert this relocation into a dynamic one.
8692
8693              For executables that use PLTs and copy-relocs, we have a
8694              choice between converting the relocation into a dynamic
8695              one or using copy relocations or PLT entries.  It is
8696              usually better to do the former, unless the relocation is
8697              against a read-only section.  */
8698           if ((bfd_link_pic (info)
8699                || (h != NULL
8700                    && !htab->is_vxworks
8701                    && strcmp (h->root.root.string, "__gnu_local_gp") != 0
8702                    && !(!info->nocopyreloc
8703                         && !PIC_OBJECT_P (abfd)
8704                         && MIPS_ELF_READONLY_SECTION (sec))))
8705               && (sec->flags & SEC_ALLOC) != 0)
8706             {
8707               can_make_dynamic_p = TRUE;
8708               if (dynobj == NULL)
8709                 elf_hash_table (info)->dynobj = dynobj = abfd;
8710             }
8711           break;
8712
8713         case R_MIPS_26:
8714         case R_MIPS_PC16:
8715         case R_MIPS_PC21_S2:
8716         case R_MIPS_PC26_S2:
8717         case R_MIPS16_26:
8718         case R_MIPS16_PC16_S1:
8719         case R_MICROMIPS_26_S1:
8720         case R_MICROMIPS_PC7_S1:
8721         case R_MICROMIPS_PC10_S1:
8722         case R_MICROMIPS_PC16_S1:
8723         case R_MICROMIPS_PC23_S2:
8724           call_reloc_p = TRUE;
8725           break;
8726         }
8727
8728       if (h)
8729         {
8730           if (constrain_symbol_p)
8731             {
8732               if (!can_make_dynamic_p)
8733                 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1;
8734
8735               if (!call_reloc_p)
8736                 h->pointer_equality_needed = 1;
8737
8738               /* We must not create a stub for a symbol that has
8739                  relocations related to taking the function's address.
8740                  This doesn't apply to VxWorks, where CALL relocs refer
8741                  to a .got.plt entry instead of a normal .got entry.  */
8742               if (!htab->is_vxworks && (!can_make_dynamic_p || !call_reloc_p))
8743                 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8744             }
8745
8746           /* Relocations against the special VxWorks __GOTT_BASE__ and
8747              __GOTT_INDEX__ symbols must be left to the loader.  Allocate
8748              room for them in .rela.dyn.  */
8749           if (is_gott_symbol (info, h))
8750             {
8751               if (sreloc == NULL)
8752                 {
8753                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
8754                   if (sreloc == NULL)
8755                     return FALSE;
8756                 }
8757               mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8758               if (MIPS_ELF_READONLY_SECTION (sec))
8759                 /* We tell the dynamic linker that there are
8760                    relocations against the text segment.  */
8761                 info->flags |= DF_TEXTREL;
8762             }
8763         }
8764       else if (call_lo16_reloc_p (r_type)
8765                || got_lo16_reloc_p (r_type)
8766                || got_disp_reloc_p (r_type)
8767                || (got16_reloc_p (r_type) && htab->is_vxworks))
8768         {
8769           /* We may need a local GOT entry for this relocation.  We
8770              don't count R_MIPS_GOT_PAGE because we can estimate the
8771              maximum number of pages needed by looking at the size of
8772              the segment.  Similar comments apply to R_MIPS*_GOT16 and
8773              R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8774              always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
8775              R_MIPS_CALL_HI16 because these are always followed by an
8776              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
8777           if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8778                                                  rel->r_addend, info, r_type))
8779             return FALSE;
8780         }
8781
8782       if (h != NULL
8783           && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8784                                                   ELF_ST_IS_MIPS16 (h->other)))
8785         ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8786
8787       switch (r_type)
8788         {
8789         case R_MIPS_CALL16:
8790         case R_MIPS16_CALL16:
8791         case R_MICROMIPS_CALL16:
8792           if (h == NULL)
8793             {
8794               _bfd_error_handler
8795                 /* xgettext:c-format */
8796                 (_("%pB: CALL16 reloc at %#" PRIx64 " not against global symbol"),
8797                  abfd, (uint64_t) rel->r_offset);
8798               bfd_set_error (bfd_error_bad_value);
8799               return FALSE;
8800             }
8801           /* Fall through.  */
8802
8803         case R_MIPS_CALL_HI16:
8804         case R_MIPS_CALL_LO16:
8805         case R_MICROMIPS_CALL_HI16:
8806         case R_MICROMIPS_CALL_LO16:
8807           if (h != NULL)
8808             {
8809               /* Make sure there is room in the regular GOT to hold the
8810                  function's address.  We may eliminate it in favour of
8811                  a .got.plt entry later; see mips_elf_count_got_symbols.  */
8812               if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
8813                                                       r_type))
8814                 return FALSE;
8815
8816               /* We need a stub, not a plt entry for the undefined
8817                  function.  But we record it as if it needs plt.  See
8818                  _bfd_elf_adjust_dynamic_symbol.  */
8819               h->needs_plt = 1;
8820               h->type = STT_FUNC;
8821             }
8822           break;
8823
8824         case R_MIPS_GOT_PAGE:
8825         case R_MICROMIPS_GOT_PAGE:
8826         case R_MIPS16_GOT16:
8827         case R_MIPS_GOT16:
8828         case R_MIPS_GOT_HI16:
8829         case R_MIPS_GOT_LO16:
8830         case R_MICROMIPS_GOT16:
8831         case R_MICROMIPS_GOT_HI16:
8832         case R_MICROMIPS_GOT_LO16:
8833           if (!h || got_page_reloc_p (r_type))
8834             {
8835               /* This relocation needs (or may need, if h != NULL) a
8836                  page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
8837                  know for sure until we know whether the symbol is
8838                  preemptible.  */
8839               if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8840                 {
8841                   if (!mips_elf_get_section_contents (abfd, sec, &contents))
8842                     return FALSE;
8843                   howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8844                   addend = mips_elf_read_rel_addend (abfd, rel,
8845                                                      howto, contents);
8846                   if (got16_reloc_p (r_type))
8847                     mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8848                                                   contents, &addend);
8849                   else
8850                     addend <<= howto->rightshift;
8851                 }
8852               else
8853                 addend = rel->r_addend;
8854               if (!mips_elf_record_got_page_ref (info, abfd, r_symndx,
8855                                                  h, addend))
8856                 return FALSE;
8857
8858               if (h)
8859                 {
8860                   struct mips_elf_link_hash_entry *hmips =
8861                     (struct mips_elf_link_hash_entry *) h;
8862
8863                   /* This symbol is definitely not overridable.  */
8864                   if (hmips->root.def_regular
8865                       && ! (bfd_link_pic (info) && ! info->symbolic
8866                             && ! hmips->root.forced_local))
8867                     h = NULL;
8868                 }
8869             }
8870           /* If this is a global, overridable symbol, GOT_PAGE will
8871              decay to GOT_DISP, so we'll need a GOT entry for it.  */
8872           /* Fall through.  */
8873
8874         case R_MIPS_GOT_DISP:
8875         case R_MICROMIPS_GOT_DISP:
8876           if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8877                                                        FALSE, r_type))
8878             return FALSE;
8879           break;
8880
8881         case R_MIPS_TLS_GOTTPREL:
8882         case R_MIPS16_TLS_GOTTPREL:
8883         case R_MICROMIPS_TLS_GOTTPREL:
8884           if (bfd_link_pic (info))
8885             info->flags |= DF_STATIC_TLS;
8886           /* Fall through */
8887
8888         case R_MIPS_TLS_LDM:
8889         case R_MIPS16_TLS_LDM:
8890         case R_MICROMIPS_TLS_LDM:
8891           if (tls_ldm_reloc_p (r_type))
8892             {
8893               r_symndx = STN_UNDEF;
8894               h = NULL;
8895             }
8896           /* Fall through */
8897
8898         case R_MIPS_TLS_GD:
8899         case R_MIPS16_TLS_GD:
8900         case R_MICROMIPS_TLS_GD:
8901           /* This symbol requires a global offset table entry, or two
8902              for TLS GD relocations.  */
8903           if (h != NULL)
8904             {
8905               if (!mips_elf_record_global_got_symbol (h, abfd, info,
8906                                                       FALSE, r_type))
8907                 return FALSE;
8908             }
8909           else
8910             {
8911               if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8912                                                      rel->r_addend,
8913                                                      info, r_type))
8914                 return FALSE;
8915             }
8916           break;
8917
8918         case R_MIPS_32:
8919         case R_MIPS_REL32:
8920         case R_MIPS_64:
8921           /* In VxWorks executables, references to external symbols
8922              are handled using copy relocs or PLT stubs, so there's
8923              no need to add a .rela.dyn entry for this relocation.  */
8924           if (can_make_dynamic_p)
8925             {
8926               if (sreloc == NULL)
8927                 {
8928                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
8929                   if (sreloc == NULL)
8930                     return FALSE;
8931                 }
8932               if (bfd_link_pic (info) && h == NULL)
8933                 {
8934                   /* When creating a shared object, we must copy these
8935                      reloc types into the output file as R_MIPS_REL32
8936                      relocs.  Make room for this reloc in .rel(a).dyn.  */
8937                   mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8938                   if (MIPS_ELF_READONLY_SECTION (sec))
8939                     /* We tell the dynamic linker that there are
8940                        relocations against the text segment.  */
8941                     info->flags |= DF_TEXTREL;
8942                 }
8943               else
8944                 {
8945                   struct mips_elf_link_hash_entry *hmips;
8946
8947                   /* For a shared object, we must copy this relocation
8948                      unless the symbol turns out to be undefined and
8949                      weak with non-default visibility, in which case
8950                      it will be left as zero.
8951
8952                      We could elide R_MIPS_REL32 for locally binding symbols
8953                      in shared libraries, but do not yet do so.
8954
8955                      For an executable, we only need to copy this
8956                      reloc if the symbol is defined in a dynamic
8957                      object.  */
8958                   hmips = (struct mips_elf_link_hash_entry *) h;
8959                   ++hmips->possibly_dynamic_relocs;
8960                   if (MIPS_ELF_READONLY_SECTION (sec))
8961                     /* We need it to tell the dynamic linker if there
8962                        are relocations against the text segment.  */
8963                     hmips->readonly_reloc = TRUE;
8964                 }
8965             }
8966
8967           if (SGI_COMPAT (abfd))
8968             mips_elf_hash_table (info)->compact_rel_size +=
8969               sizeof (Elf32_External_crinfo);
8970           break;
8971
8972         case R_MIPS_26:
8973         case R_MIPS_GPREL16:
8974         case R_MIPS_LITERAL:
8975         case R_MIPS_GPREL32:
8976         case R_MICROMIPS_26_S1:
8977         case R_MICROMIPS_GPREL16:
8978         case R_MICROMIPS_LITERAL:
8979         case R_MICROMIPS_GPREL7_S2:
8980           if (SGI_COMPAT (abfd))
8981             mips_elf_hash_table (info)->compact_rel_size +=
8982               sizeof (Elf32_External_crinfo);
8983           break;
8984
8985           /* This relocation describes the C++ object vtable hierarchy.
8986              Reconstruct it for later use during GC.  */
8987         case R_MIPS_GNU_VTINHERIT:
8988           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8989             return FALSE;
8990           break;
8991
8992           /* This relocation describes which C++ vtable entries are actually
8993              used.  Record for later use during GC.  */
8994         case R_MIPS_GNU_VTENTRY:
8995           BFD_ASSERT (h != NULL);
8996           if (h != NULL
8997               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8998             return FALSE;
8999           break;
9000
9001         default:
9002           break;
9003         }
9004
9005       /* Record the need for a PLT entry.  At this point we don't know
9006          yet if we are going to create a PLT in the first place, but
9007          we only record whether the relocation requires a standard MIPS
9008          or a compressed code entry anyway.  If we don't make a PLT after
9009          all, then we'll just ignore these arrangements.  Likewise if
9010          a PLT entry is not created because the symbol is satisfied
9011          locally.  */
9012       if (h != NULL
9013           && (branch_reloc_p (r_type)
9014               || mips16_branch_reloc_p (r_type)
9015               || micromips_branch_reloc_p (r_type))
9016           && !SYMBOL_CALLS_LOCAL (info, h))
9017         {
9018           if (h->plt.plist == NULL)
9019             h->plt.plist = mips_elf_make_plt_record (abfd);
9020           if (h->plt.plist == NULL)
9021             return FALSE;
9022
9023           if (branch_reloc_p (r_type))
9024             h->plt.plist->need_mips = TRUE;
9025           else
9026             h->plt.plist->need_comp = TRUE;
9027         }
9028
9029       /* See if this reloc would need to refer to a MIPS16 hard-float stub,
9030          if there is one.  We only need to handle global symbols here;
9031          we decide whether to keep or delete stubs for local symbols
9032          when processing the stub's relocations.  */
9033       if (h != NULL
9034           && !mips16_call_reloc_p (r_type)
9035           && !section_allows_mips16_refs_p (sec))
9036         {
9037           struct mips_elf_link_hash_entry *mh;
9038
9039           mh = (struct mips_elf_link_hash_entry *) h;
9040           mh->need_fn_stub = TRUE;
9041         }
9042
9043       /* Refuse some position-dependent relocations when creating a
9044          shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
9045          not PIC, but we can create dynamic relocations and the result
9046          will be fine.  Also do not refuse R_MIPS_LO16, which can be
9047          combined with R_MIPS_GOT16.  */
9048       if (bfd_link_pic (info))
9049         {
9050           switch (r_type)
9051             {
9052             case R_MIPS16_HI16:
9053             case R_MIPS_HI16:
9054             case R_MIPS_HIGHER:
9055             case R_MIPS_HIGHEST:
9056             case R_MICROMIPS_HI16:
9057             case R_MICROMIPS_HIGHER:
9058             case R_MICROMIPS_HIGHEST:
9059               /* Don't refuse a high part relocation if it's against
9060                  no symbol (e.g. part of a compound relocation).  */
9061               if (r_symndx == STN_UNDEF)
9062                 break;
9063
9064               /* Likewise an absolute symbol.  */
9065               if (bfd_is_abs_symbol (&h->root))
9066                 break;
9067
9068               /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
9069                  and has a special meaning.  */
9070               if (!NEWABI_P (abfd) && h != NULL
9071                   && strcmp (h->root.root.string, "_gp_disp") == 0)
9072                 break;
9073
9074               /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks.  */
9075               if (is_gott_symbol (info, h))
9076                 break;
9077
9078               /* FALLTHROUGH */
9079
9080             case R_MIPS16_26:
9081             case R_MIPS_26:
9082             case R_MICROMIPS_26_S1:
9083               howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
9084               info->callbacks->einfo
9085                 /* xgettext:c-format */
9086                 (_("%X%H: relocation %s against `%s' cannot be used"
9087                    " when making a shared object; recompile with -fPIC\n"),
9088                  abfd, sec, rel->r_offset, howto->name,
9089                  (h) ? h->root.root.string : "a local symbol");
9090               break;
9091             default:
9092               break;
9093             }
9094         }
9095     }
9096
9097   return TRUE;
9098 }
9099 \f
9100 /* Allocate space for global sym dynamic relocs.  */
9101
9102 static bfd_boolean
9103 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9104 {
9105   struct bfd_link_info *info = inf;
9106   bfd *dynobj;
9107   struct mips_elf_link_hash_entry *hmips;
9108   struct mips_elf_link_hash_table *htab;
9109
9110   htab = mips_elf_hash_table (info);
9111   BFD_ASSERT (htab != NULL);
9112
9113   dynobj = elf_hash_table (info)->dynobj;
9114   hmips = (struct mips_elf_link_hash_entry *) h;
9115
9116   /* VxWorks executables are handled elsewhere; we only need to
9117      allocate relocations in shared objects.  */
9118   if (htab->is_vxworks && !bfd_link_pic (info))
9119     return TRUE;
9120
9121   /* Ignore indirect symbols.  All relocations against such symbols
9122      will be redirected to the target symbol.  */
9123   if (h->root.type == bfd_link_hash_indirect)
9124     return TRUE;
9125
9126   /* If this symbol is defined in a dynamic object, or we are creating
9127      a shared library, we will need to copy any R_MIPS_32 or
9128      R_MIPS_REL32 relocs against it into the output file.  */
9129   if (! bfd_link_relocatable (info)
9130       && hmips->possibly_dynamic_relocs != 0
9131       && (h->root.type == bfd_link_hash_defweak
9132           || (!h->def_regular && !ELF_COMMON_DEF_P (h))
9133           || bfd_link_pic (info)))
9134     {
9135       bfd_boolean do_copy = TRUE;
9136
9137       if (h->root.type == bfd_link_hash_undefweak)
9138         {
9139           /* Do not copy relocations for undefined weak symbols that
9140              we are not going to export.  */
9141           if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9142             do_copy = FALSE;
9143
9144           /* Make sure undefined weak symbols are output as a dynamic
9145              symbol in PIEs.  */
9146           else if (h->dynindx == -1 && !h->forced_local)
9147             {
9148               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9149                 return FALSE;
9150             }
9151         }
9152
9153       if (do_copy)
9154         {
9155           /* Even though we don't directly need a GOT entry for this symbol,
9156              the SVR4 psABI requires it to have a dynamic symbol table
9157              index greater that DT_MIPS_GOTSYM if there are dynamic
9158              relocations against it.
9159
9160              VxWorks does not enforce the same mapping between the GOT
9161              and the symbol table, so the same requirement does not
9162              apply there.  */
9163           if (!htab->is_vxworks)
9164             {
9165               if (hmips->global_got_area > GGA_RELOC_ONLY)
9166                 hmips->global_got_area = GGA_RELOC_ONLY;
9167               hmips->got_only_for_calls = FALSE;
9168             }
9169
9170           mips_elf_allocate_dynamic_relocations
9171             (dynobj, info, hmips->possibly_dynamic_relocs);
9172           if (hmips->readonly_reloc)
9173             /* We tell the dynamic linker that there are relocations
9174                against the text segment.  */
9175             info->flags |= DF_TEXTREL;
9176         }
9177     }
9178
9179   return TRUE;
9180 }
9181
9182 /* Adjust a symbol defined by a dynamic object and referenced by a
9183    regular object.  The current definition is in some section of the
9184    dynamic object, but we're not including those sections.  We have to
9185    change the definition to something the rest of the link can
9186    understand.  */
9187
9188 bfd_boolean
9189 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
9190                                      struct elf_link_hash_entry *h)
9191 {
9192   bfd *dynobj;
9193   struct mips_elf_link_hash_entry *hmips;
9194   struct mips_elf_link_hash_table *htab;
9195   asection *s, *srel;
9196
9197   htab = mips_elf_hash_table (info);
9198   BFD_ASSERT (htab != NULL);
9199
9200   dynobj = elf_hash_table (info)->dynobj;
9201   hmips = (struct mips_elf_link_hash_entry *) h;
9202
9203   /* Make sure we know what is going on here.  */
9204   BFD_ASSERT (dynobj != NULL
9205               && (h->needs_plt
9206                   || h->is_weakalias
9207                   || (h->def_dynamic
9208                       && h->ref_regular
9209                       && !h->def_regular)));
9210
9211   hmips = (struct mips_elf_link_hash_entry *) h;
9212
9213   /* If there are call relocations against an externally-defined symbol,
9214      see whether we can create a MIPS lazy-binding stub for it.  We can
9215      only do this if all references to the function are through call
9216      relocations, and in that case, the traditional lazy-binding stubs
9217      are much more efficient than PLT entries.
9218
9219      Traditional stubs are only available on SVR4 psABI-based systems;
9220      VxWorks always uses PLTs instead.  */
9221   if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
9222     {
9223       if (! elf_hash_table (info)->dynamic_sections_created)
9224         return TRUE;
9225
9226       /* If this symbol is not defined in a regular file, then set
9227          the symbol to the stub location.  This is required to make
9228          function pointers compare as equal between the normal
9229          executable and the shared library.  */
9230       if (!h->def_regular
9231           && !bfd_is_abs_section (htab->sstubs->output_section))
9232         {
9233           hmips->needs_lazy_stub = TRUE;
9234           htab->lazy_stub_count++;
9235           return TRUE;
9236         }
9237     }
9238   /* As above, VxWorks requires PLT entries for externally-defined
9239      functions that are only accessed through call relocations.
9240
9241      Both VxWorks and non-VxWorks targets also need PLT entries if there
9242      are static-only relocations against an externally-defined function.
9243      This can technically occur for shared libraries if there are
9244      branches to the symbol, although it is unlikely that this will be
9245      used in practice due to the short ranges involved.  It can occur
9246      for any relative or absolute relocation in executables; in that
9247      case, the PLT entry becomes the function's canonical address.  */
9248   else if (((h->needs_plt && !hmips->no_fn_stub)
9249             || (h->type == STT_FUNC && hmips->has_static_relocs))
9250            && htab->use_plts_and_copy_relocs
9251            && !SYMBOL_CALLS_LOCAL (info, h)
9252            && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9253                 && h->root.type == bfd_link_hash_undefweak))
9254     {
9255       bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9256       bfd_boolean newabi_p = NEWABI_P (info->output_bfd);
9257
9258       /* If this is the first symbol to need a PLT entry, then make some
9259          basic setup.  Also work out PLT entry sizes.  We'll need them
9260          for PLT offset calculations.  */
9261       if (htab->plt_mips_offset + htab->plt_comp_offset == 0)
9262         {
9263           BFD_ASSERT (htab->root.sgotplt->size == 0);
9264           BFD_ASSERT (htab->plt_got_index == 0);
9265
9266           /* If we're using the PLT additions to the psABI, each PLT
9267              entry is 16 bytes and the PLT0 entry is 32 bytes.
9268              Encourage better cache usage by aligning.  We do this
9269              lazily to avoid pessimizing traditional objects.  */
9270           if (!htab->is_vxworks
9271               && !bfd_set_section_alignment (dynobj, htab->root.splt, 5))
9272             return FALSE;
9273
9274           /* Make sure that .got.plt is word-aligned.  We do this lazily
9275              for the same reason as above.  */
9276           if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt,
9277                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
9278             return FALSE;
9279
9280           /* On non-VxWorks targets, the first two entries in .got.plt
9281              are reserved.  */
9282           if (!htab->is_vxworks)
9283             htab->plt_got_index
9284               += (get_elf_backend_data (dynobj)->got_header_size
9285                   / MIPS_ELF_GOT_SIZE (dynobj));
9286
9287           /* On VxWorks, also allocate room for the header's
9288              .rela.plt.unloaded entries.  */
9289           if (htab->is_vxworks && !bfd_link_pic (info))
9290             htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
9291
9292           /* Now work out the sizes of individual PLT entries.  */
9293           if (htab->is_vxworks && bfd_link_pic (info))
9294             htab->plt_mips_entry_size
9295               = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
9296           else if (htab->is_vxworks)
9297             htab->plt_mips_entry_size
9298               = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
9299           else if (newabi_p)
9300             htab->plt_mips_entry_size
9301               = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9302           else if (!micromips_p)
9303             {
9304               htab->plt_mips_entry_size
9305                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9306               htab->plt_comp_entry_size
9307                 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
9308             }
9309           else if (htab->insn32)
9310             {
9311               htab->plt_mips_entry_size
9312                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9313               htab->plt_comp_entry_size
9314                 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
9315             }
9316           else
9317             {
9318               htab->plt_mips_entry_size
9319                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9320               htab->plt_comp_entry_size
9321                 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
9322             }
9323         }
9324
9325       if (h->plt.plist == NULL)
9326         h->plt.plist = mips_elf_make_plt_record (dynobj);
9327       if (h->plt.plist == NULL)
9328         return FALSE;
9329
9330       /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9331          n32 or n64, so always use a standard entry there.
9332
9333          If the symbol has a MIPS16 call stub and gets a PLT entry, then
9334          all MIPS16 calls will go via that stub, and there is no benefit
9335          to having a MIPS16 entry.  And in the case of call_stub a
9336          standard entry actually has to be used as the stub ends with a J
9337          instruction.  */
9338       if (newabi_p
9339           || htab->is_vxworks
9340           || hmips->call_stub
9341           || hmips->call_fp_stub)
9342         {
9343           h->plt.plist->need_mips = TRUE;
9344           h->plt.plist->need_comp = FALSE;
9345         }
9346
9347       /* Otherwise, if there are no direct calls to the function, we
9348          have a free choice of whether to use standard or compressed
9349          entries.  Prefer microMIPS entries if the object is known to
9350          contain microMIPS code, so that it becomes possible to create
9351          pure microMIPS binaries.  Prefer standard entries otherwise,
9352          because MIPS16 ones are no smaller and are usually slower.  */
9353       if (!h->plt.plist->need_mips && !h->plt.plist->need_comp)
9354         {
9355           if (micromips_p)
9356             h->plt.plist->need_comp = TRUE;
9357           else
9358             h->plt.plist->need_mips = TRUE;
9359         }
9360
9361       if (h->plt.plist->need_mips)
9362         {
9363           h->plt.plist->mips_offset = htab->plt_mips_offset;
9364           htab->plt_mips_offset += htab->plt_mips_entry_size;
9365         }
9366       if (h->plt.plist->need_comp)
9367         {
9368           h->plt.plist->comp_offset = htab->plt_comp_offset;
9369           htab->plt_comp_offset += htab->plt_comp_entry_size;
9370         }
9371
9372       /* Reserve the corresponding .got.plt entry now too.  */
9373       h->plt.plist->gotplt_index = htab->plt_got_index++;
9374
9375       /* If the output file has no definition of the symbol, set the
9376          symbol's value to the address of the stub.  */
9377       if (!bfd_link_pic (info) && !h->def_regular)
9378         hmips->use_plt_entry = TRUE;
9379
9380       /* Make room for the R_MIPS_JUMP_SLOT relocation.  */
9381       htab->root.srelplt->size += (htab->is_vxworks
9382                                    ? MIPS_ELF_RELA_SIZE (dynobj)
9383                                    : MIPS_ELF_REL_SIZE (dynobj));
9384
9385       /* Make room for the .rela.plt.unloaded relocations.  */
9386       if (htab->is_vxworks && !bfd_link_pic (info))
9387         htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
9388
9389       /* All relocations against this symbol that could have been made
9390          dynamic will now refer to the PLT entry instead.  */
9391       hmips->possibly_dynamic_relocs = 0;
9392
9393       return TRUE;
9394     }
9395
9396   /* If this is a weak symbol, and there is a real definition, the
9397      processor independent code will have arranged for us to see the
9398      real definition first, and we can just use the same value.  */
9399   if (h->is_weakalias)
9400     {
9401       struct elf_link_hash_entry *def = weakdef (h);
9402       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
9403       h->root.u.def.section = def->root.u.def.section;
9404       h->root.u.def.value = def->root.u.def.value;
9405       return TRUE;
9406     }
9407
9408   /* Otherwise, there is nothing further to do for symbols defined
9409      in regular objects.  */
9410   if (h->def_regular)
9411     return TRUE;
9412
9413   /* There's also nothing more to do if we'll convert all relocations
9414      against this symbol into dynamic relocations.  */
9415   if (!hmips->has_static_relocs)
9416     return TRUE;
9417
9418   /* We're now relying on copy relocations.  Complain if we have
9419      some that we can't convert.  */
9420   if (!htab->use_plts_and_copy_relocs || bfd_link_pic (info))
9421     {
9422       _bfd_error_handler (_("non-dynamic relocations refer to "
9423                             "dynamic symbol %s"),
9424                           h->root.root.string);
9425       bfd_set_error (bfd_error_bad_value);
9426       return FALSE;
9427     }
9428
9429   /* We must allocate the symbol in our .dynbss section, which will
9430      become part of the .bss section of the executable.  There will be
9431      an entry for this symbol in the .dynsym section.  The dynamic
9432      object will contain position independent code, so all references
9433      from the dynamic object to this symbol will go through the global
9434      offset table.  The dynamic linker will use the .dynsym entry to
9435      determine the address it must put in the global offset table, so
9436      both the dynamic object and the regular object will refer to the
9437      same memory location for the variable.  */
9438
9439   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
9440     {
9441       s = htab->root.sdynrelro;
9442       srel = htab->root.sreldynrelro;
9443     }
9444   else
9445     {
9446       s = htab->root.sdynbss;
9447       srel = htab->root.srelbss;
9448     }
9449   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
9450     {
9451       if (htab->is_vxworks)
9452         srel->size += sizeof (Elf32_External_Rela);
9453       else
9454         mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
9455       h->needs_copy = 1;
9456     }
9457
9458   /* All relocations against this symbol that could have been made
9459      dynamic will now refer to the local copy instead.  */
9460   hmips->possibly_dynamic_relocs = 0;
9461
9462   return _bfd_elf_adjust_dynamic_copy (info, h, s);
9463 }
9464 \f
9465 /* This function is called after all the input files have been read,
9466    and the input sections have been assigned to output sections.  We
9467    check for any mips16 stub sections that we can discard.  */
9468
9469 bfd_boolean
9470 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
9471                                     struct bfd_link_info *info)
9472 {
9473   asection *sect;
9474   struct mips_elf_link_hash_table *htab;
9475   struct mips_htab_traverse_info hti;
9476
9477   htab = mips_elf_hash_table (info);
9478   BFD_ASSERT (htab != NULL);
9479
9480   /* The .reginfo section has a fixed size.  */
9481   sect = bfd_get_section_by_name (output_bfd, ".reginfo");
9482   if (sect != NULL)
9483     {
9484       bfd_set_section_size (output_bfd, sect, sizeof (Elf32_External_RegInfo));
9485       sect->flags |= SEC_FIXED_SIZE | SEC_HAS_CONTENTS;
9486     }
9487
9488   /* The .MIPS.abiflags section has a fixed size.  */
9489   sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags");
9490   if (sect != NULL)
9491     {
9492       bfd_set_section_size (output_bfd, sect,
9493                             sizeof (Elf_External_ABIFlags_v0));
9494       sect->flags |= SEC_FIXED_SIZE | SEC_HAS_CONTENTS;
9495     }
9496
9497   hti.info = info;
9498   hti.output_bfd = output_bfd;
9499   hti.error = FALSE;
9500   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9501                                mips_elf_check_symbols, &hti);
9502   if (hti.error)
9503     return FALSE;
9504
9505   return TRUE;
9506 }
9507
9508 /* If the link uses a GOT, lay it out and work out its size.  */
9509
9510 static bfd_boolean
9511 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
9512 {
9513   bfd *dynobj;
9514   asection *s;
9515   struct mips_got_info *g;
9516   bfd_size_type loadable_size = 0;
9517   bfd_size_type page_gotno;
9518   bfd *ibfd;
9519   struct mips_elf_traverse_got_arg tga;
9520   struct mips_elf_link_hash_table *htab;
9521
9522   htab = mips_elf_hash_table (info);
9523   BFD_ASSERT (htab != NULL);
9524
9525   s = htab->root.sgot;
9526   if (s == NULL)
9527     return TRUE;
9528
9529   dynobj = elf_hash_table (info)->dynobj;
9530   g = htab->got_info;
9531
9532   /* Allocate room for the reserved entries.  VxWorks always reserves
9533      3 entries; other objects only reserve 2 entries.  */
9534   BFD_ASSERT (g->assigned_low_gotno == 0);
9535   if (htab->is_vxworks)
9536     htab->reserved_gotno = 3;
9537   else
9538     htab->reserved_gotno = 2;
9539   g->local_gotno += htab->reserved_gotno;
9540   g->assigned_low_gotno = htab->reserved_gotno;
9541
9542   /* Decide which symbols need to go in the global part of the GOT and
9543      count the number of reloc-only GOT symbols.  */
9544   mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
9545
9546   if (!mips_elf_resolve_final_got_entries (info, g))
9547     return FALSE;
9548
9549   /* Calculate the total loadable size of the output.  That
9550      will give us the maximum number of GOT_PAGE entries
9551      required.  */
9552   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9553     {
9554       asection *subsection;
9555
9556       for (subsection = ibfd->sections;
9557            subsection;
9558            subsection = subsection->next)
9559         {
9560           if ((subsection->flags & SEC_ALLOC) == 0)
9561             continue;
9562           loadable_size += ((subsection->size + 0xf)
9563                             &~ (bfd_size_type) 0xf);
9564         }
9565     }
9566
9567   if (htab->is_vxworks)
9568     /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9569        relocations against local symbols evaluate to "G", and the EABI does
9570        not include R_MIPS_GOT_PAGE.  */
9571     page_gotno = 0;
9572   else
9573     /* Assume there are two loadable segments consisting of contiguous
9574        sections.  Is 5 enough?  */
9575     page_gotno = (loadable_size >> 16) + 5;
9576
9577   /* Choose the smaller of the two page estimates; both are intended to be
9578      conservative.  */
9579   if (page_gotno > g->page_gotno)
9580     page_gotno = g->page_gotno;
9581
9582   g->local_gotno += page_gotno;
9583   g->assigned_high_gotno = g->local_gotno - 1;
9584
9585   s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9586   s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9587   s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9588
9589   /* VxWorks does not support multiple GOTs.  It initializes $gp to
9590      __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9591      dynamic loader.  */
9592   if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
9593     {
9594       if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
9595         return FALSE;
9596     }
9597   else
9598     {
9599       /* Record that all bfds use G.  This also has the effect of freeing
9600          the per-bfd GOTs, which we no longer need.  */
9601       for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9602         if (mips_elf_bfd_got (ibfd, FALSE))
9603           mips_elf_replace_bfd_got (ibfd, g);
9604       mips_elf_replace_bfd_got (output_bfd, g);
9605
9606       /* Set up TLS entries.  */
9607       g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
9608       tga.info = info;
9609       tga.g = g;
9610       tga.value = MIPS_ELF_GOT_SIZE (output_bfd);
9611       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
9612       if (!tga.g)
9613         return FALSE;
9614       BFD_ASSERT (g->tls_assigned_gotno
9615                   == g->global_gotno + g->local_gotno + g->tls_gotno);
9616
9617       /* Each VxWorks GOT entry needs an explicit relocation.  */
9618       if (htab->is_vxworks && bfd_link_pic (info))
9619         g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno;
9620
9621       /* Allocate room for the TLS relocations.  */
9622       if (g->relocs)
9623         mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
9624     }
9625
9626   return TRUE;
9627 }
9628
9629 /* Estimate the size of the .MIPS.stubs section.  */
9630
9631 static void
9632 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
9633 {
9634   struct mips_elf_link_hash_table *htab;
9635   bfd_size_type dynsymcount;
9636
9637   htab = mips_elf_hash_table (info);
9638   BFD_ASSERT (htab != NULL);
9639
9640   if (htab->lazy_stub_count == 0)
9641     return;
9642
9643   /* IRIX rld assumes that a function stub isn't at the end of the .text
9644      section, so add a dummy entry to the end.  */
9645   htab->lazy_stub_count++;
9646
9647   /* Get a worst-case estimate of the number of dynamic symbols needed.
9648      At this point, dynsymcount does not account for section symbols
9649      and count_section_dynsyms may overestimate the number that will
9650      be needed.  */
9651   dynsymcount = (elf_hash_table (info)->dynsymcount
9652                  + count_section_dynsyms (output_bfd, info));
9653
9654   /* Determine the size of one stub entry.  There's no disadvantage
9655      from using microMIPS code here, so for the sake of pure-microMIPS
9656      binaries we prefer it whenever there's any microMIPS code in
9657      output produced at all.  This has a benefit of stubs being
9658      shorter by 4 bytes each too, unless in the insn32 mode.  */
9659   if (!MICROMIPS_P (output_bfd))
9660     htab->function_stub_size = (dynsymcount > 0x10000
9661                                 ? MIPS_FUNCTION_STUB_BIG_SIZE
9662                                 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
9663   else if (htab->insn32)
9664     htab->function_stub_size = (dynsymcount > 0x10000
9665                                 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9666                                 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE);
9667   else
9668     htab->function_stub_size = (dynsymcount > 0x10000
9669                                 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9670                                 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE);
9671
9672   htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
9673 }
9674
9675 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9676    mips_htab_traverse_info.  If H needs a traditional MIPS lazy-binding
9677    stub, allocate an entry in the stubs section.  */
9678
9679 static bfd_boolean
9680 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data)
9681 {
9682   struct mips_htab_traverse_info *hti = data;
9683   struct mips_elf_link_hash_table *htab;
9684   struct bfd_link_info *info;
9685   bfd *output_bfd;
9686
9687   info = hti->info;
9688   output_bfd = hti->output_bfd;
9689   htab = mips_elf_hash_table (info);
9690   BFD_ASSERT (htab != NULL);
9691
9692   if (h->needs_lazy_stub)
9693     {
9694       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9695       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9696       bfd_vma isa_bit = micromips_p;
9697
9698       BFD_ASSERT (htab->root.dynobj != NULL);
9699       if (h->root.plt.plist == NULL)
9700         h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner);
9701       if (h->root.plt.plist == NULL)
9702         {
9703           hti->error = TRUE;
9704           return FALSE;
9705         }
9706       h->root.root.u.def.section = htab->sstubs;
9707       h->root.root.u.def.value = htab->sstubs->size + isa_bit;
9708       h->root.plt.plist->stub_offset = htab->sstubs->size;
9709       h->root.other = other;
9710       htab->sstubs->size += htab->function_stub_size;
9711     }
9712   return TRUE;
9713 }
9714
9715 /* Allocate offsets in the stubs section to each symbol that needs one.
9716    Set the final size of the .MIPS.stub section.  */
9717
9718 static bfd_boolean
9719 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
9720 {
9721   bfd *output_bfd = info->output_bfd;
9722   bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9723   unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9724   bfd_vma isa_bit = micromips_p;
9725   struct mips_elf_link_hash_table *htab;
9726   struct mips_htab_traverse_info hti;
9727   struct elf_link_hash_entry *h;
9728   bfd *dynobj;
9729
9730   htab = mips_elf_hash_table (info);
9731   BFD_ASSERT (htab != NULL);
9732
9733   if (htab->lazy_stub_count == 0)
9734     return TRUE;
9735
9736   htab->sstubs->size = 0;
9737   hti.info = info;
9738   hti.output_bfd = output_bfd;
9739   hti.error = FALSE;
9740   mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti);
9741   if (hti.error)
9742     return FALSE;
9743   htab->sstubs->size += htab->function_stub_size;
9744   BFD_ASSERT (htab->sstubs->size
9745               == htab->lazy_stub_count * htab->function_stub_size);
9746
9747   dynobj = elf_hash_table (info)->dynobj;
9748   BFD_ASSERT (dynobj != NULL);
9749   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_");
9750   if (h == NULL)
9751     return FALSE;
9752   h->root.u.def.value = isa_bit;
9753   h->other = other;
9754   h->type = STT_FUNC;
9755
9756   return TRUE;
9757 }
9758
9759 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9760    bfd_link_info.  If H uses the address of a PLT entry as the value
9761    of the symbol, then set the entry in the symbol table now.  Prefer
9762    a standard MIPS PLT entry.  */
9763
9764 static bfd_boolean
9765 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data)
9766 {
9767   struct bfd_link_info *info = data;
9768   bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9769   struct mips_elf_link_hash_table *htab;
9770   unsigned int other;
9771   bfd_vma isa_bit;
9772   bfd_vma val;
9773
9774   htab = mips_elf_hash_table (info);
9775   BFD_ASSERT (htab != NULL);
9776
9777   if (h->use_plt_entry)
9778     {
9779       BFD_ASSERT (h->root.plt.plist != NULL);
9780       BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE
9781                   || h->root.plt.plist->comp_offset != MINUS_ONE);
9782
9783       val = htab->plt_header_size;
9784       if (h->root.plt.plist->mips_offset != MINUS_ONE)
9785         {
9786           isa_bit = 0;
9787           val += h->root.plt.plist->mips_offset;
9788           other = 0;
9789         }
9790       else
9791         {
9792           isa_bit = 1;
9793           val += htab->plt_mips_offset + h->root.plt.plist->comp_offset;
9794           other = micromips_p ? STO_MICROMIPS : STO_MIPS16;
9795         }
9796       val += isa_bit;
9797       /* For VxWorks, point at the PLT load stub rather than the lazy
9798          resolution stub; this stub will become the canonical function
9799          address.  */
9800       if (htab->is_vxworks)
9801         val += 8;
9802
9803       h->root.root.u.def.section = htab->root.splt;
9804       h->root.root.u.def.value = val;
9805       h->root.other = other;
9806     }
9807
9808   return TRUE;
9809 }
9810
9811 /* Set the sizes of the dynamic sections.  */
9812
9813 bfd_boolean
9814 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9815                                      struct bfd_link_info *info)
9816 {
9817   bfd *dynobj;
9818   asection *s, *sreldyn;
9819   bfd_boolean reltext;
9820   struct mips_elf_link_hash_table *htab;
9821
9822   htab = mips_elf_hash_table (info);
9823   BFD_ASSERT (htab != NULL);
9824   dynobj = elf_hash_table (info)->dynobj;
9825   BFD_ASSERT (dynobj != NULL);
9826
9827   if (elf_hash_table (info)->dynamic_sections_created)
9828     {
9829       /* Set the contents of the .interp section to the interpreter.  */
9830       if (bfd_link_executable (info) && !info->nointerp)
9831         {
9832           s = bfd_get_linker_section (dynobj, ".interp");
9833           BFD_ASSERT (s != NULL);
9834           s->size
9835             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9836           s->contents
9837             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9838         }
9839
9840       /* Figure out the size of the PLT header if we know that we
9841          are using it.  For the sake of cache alignment always use
9842          a standard header whenever any standard entries are present
9843          even if microMIPS entries are present as well.  This also
9844          lets the microMIPS header rely on the value of $v0 only set
9845          by microMIPS entries, for a small size reduction.
9846
9847          Set symbol table entry values for symbols that use the
9848          address of their PLT entry now that we can calculate it.
9849
9850          Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9851          haven't already in _bfd_elf_create_dynamic_sections.  */
9852       if (htab->root.splt && htab->plt_mips_offset + htab->plt_comp_offset != 0)
9853         {
9854           bfd_boolean micromips_p = (MICROMIPS_P (output_bfd)
9855                                      && !htab->plt_mips_offset);
9856           unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9857           bfd_vma isa_bit = micromips_p;
9858           struct elf_link_hash_entry *h;
9859           bfd_vma size;
9860
9861           BFD_ASSERT (htab->use_plts_and_copy_relocs);
9862           BFD_ASSERT (htab->root.sgotplt->size == 0);
9863           BFD_ASSERT (htab->root.splt->size == 0);
9864
9865           if (htab->is_vxworks && bfd_link_pic (info))
9866             size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
9867           else if (htab->is_vxworks)
9868             size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
9869           else if (ABI_64_P (output_bfd))
9870             size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry);
9871           else if (ABI_N32_P (output_bfd))
9872             size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry);
9873           else if (!micromips_p)
9874             size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
9875           else if (htab->insn32)
9876             size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
9877           else
9878             size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
9879
9880           htab->plt_header_is_comp = micromips_p;
9881           htab->plt_header_size = size;
9882           htab->root.splt->size = (size
9883                                    + htab->plt_mips_offset
9884                                    + htab->plt_comp_offset);
9885           htab->root.sgotplt->size = (htab->plt_got_index
9886                                       * MIPS_ELF_GOT_SIZE (dynobj));
9887
9888           mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info);
9889
9890           if (htab->root.hplt == NULL)
9891             {
9892               h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.splt,
9893                                                "_PROCEDURE_LINKAGE_TABLE_");
9894               htab->root.hplt = h;
9895               if (h == NULL)
9896                 return FALSE;
9897             }
9898
9899           h = htab->root.hplt;
9900           h->root.u.def.value = isa_bit;
9901           h->other = other;
9902           h->type = STT_FUNC;
9903         }
9904     }
9905
9906   /* Allocate space for global sym dynamic relocs.  */
9907   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9908
9909   mips_elf_estimate_stub_size (output_bfd, info);
9910
9911   if (!mips_elf_lay_out_got (output_bfd, info))
9912     return FALSE;
9913
9914   mips_elf_lay_out_lazy_stubs (info);
9915
9916   /* The check_relocs and adjust_dynamic_symbol entry points have
9917      determined the sizes of the various dynamic sections.  Allocate
9918      memory for them.  */
9919   reltext = FALSE;
9920   for (s = dynobj->sections; s != NULL; s = s->next)
9921     {
9922       const char *name;
9923
9924       /* It's OK to base decisions on the section name, because none
9925          of the dynobj section names depend upon the input files.  */
9926       name = bfd_get_section_name (dynobj, s);
9927
9928       if ((s->flags & SEC_LINKER_CREATED) == 0)
9929         continue;
9930
9931       if (CONST_STRNEQ (name, ".rel"))
9932         {
9933           if (s->size != 0)
9934             {
9935               const char *outname;
9936               asection *target;
9937
9938               /* If this relocation section applies to a read only
9939                  section, then we probably need a DT_TEXTREL entry.
9940                  If the relocation section is .rel(a).dyn, we always
9941                  assert a DT_TEXTREL entry rather than testing whether
9942                  there exists a relocation to a read only section or
9943                  not.  */
9944               outname = bfd_get_section_name (output_bfd,
9945                                               s->output_section);
9946               target = bfd_get_section_by_name (output_bfd, outname + 4);
9947               if ((target != NULL
9948                    && (target->flags & SEC_READONLY) != 0
9949                    && (target->flags & SEC_ALLOC) != 0)
9950                   || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9951                 reltext = TRUE;
9952
9953               /* We use the reloc_count field as a counter if we need
9954                  to copy relocs into the output file.  */
9955               if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9956                 s->reloc_count = 0;
9957
9958               /* If combreloc is enabled, elf_link_sort_relocs() will
9959                  sort relocations, but in a different way than we do,
9960                  and before we're done creating relocations.  Also, it
9961                  will move them around between input sections'
9962                  relocation's contents, so our sorting would be
9963                  broken, so don't let it run.  */
9964               info->combreloc = 0;
9965             }
9966         }
9967       else if (bfd_link_executable (info)
9968                && ! mips_elf_hash_table (info)->use_rld_obj_head
9969                && CONST_STRNEQ (name, ".rld_map"))
9970         {
9971           /* We add a room for __rld_map.  It will be filled in by the
9972              rtld to contain a pointer to the _r_debug structure.  */
9973           s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9974         }
9975       else if (SGI_COMPAT (output_bfd)
9976                && CONST_STRNEQ (name, ".compact_rel"))
9977         s->size += mips_elf_hash_table (info)->compact_rel_size;
9978       else if (s == htab->root.splt)
9979         {
9980           /* If the last PLT entry has a branch delay slot, allocate
9981              room for an extra nop to fill the delay slot.  This is
9982              for CPUs without load interlocking.  */
9983           if (! LOAD_INTERLOCKS_P (output_bfd)
9984               && ! htab->is_vxworks && s->size > 0)
9985             s->size += 4;
9986         }
9987       else if (! CONST_STRNEQ (name, ".init")
9988                && s != htab->root.sgot
9989                && s != htab->root.sgotplt
9990                && s != htab->sstubs
9991                && s != htab->root.sdynbss
9992                && s != htab->root.sdynrelro)
9993         {
9994           /* It's not one of our sections, so don't allocate space.  */
9995           continue;
9996         }
9997
9998       if (s->size == 0)
9999         {
10000           s->flags |= SEC_EXCLUDE;
10001           continue;
10002         }
10003
10004       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10005         continue;
10006
10007       /* Allocate memory for the section contents.  */
10008       s->contents = bfd_zalloc (dynobj, s->size);
10009       if (s->contents == NULL)
10010         {
10011           bfd_set_error (bfd_error_no_memory);
10012           return FALSE;
10013         }
10014     }
10015
10016   if (elf_hash_table (info)->dynamic_sections_created)
10017     {
10018       /* Add some entries to the .dynamic section.  We fill in the
10019          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
10020          must add the entries now so that we get the correct size for
10021          the .dynamic section.  */
10022
10023       /* SGI object has the equivalence of DT_DEBUG in the
10024          DT_MIPS_RLD_MAP entry.  This must come first because glibc
10025          only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
10026          may only look at the first one they see.  */
10027       if (!bfd_link_pic (info)
10028           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
10029         return FALSE;
10030
10031       if (bfd_link_executable (info)
10032           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0))
10033         return FALSE;
10034
10035       /* The DT_DEBUG entry may be filled in by the dynamic linker and
10036          used by the debugger.  */
10037       if (bfd_link_executable (info)
10038           && !SGI_COMPAT (output_bfd)
10039           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
10040         return FALSE;
10041
10042       if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
10043         info->flags |= DF_TEXTREL;
10044
10045       if ((info->flags & DF_TEXTREL) != 0)
10046         {
10047           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
10048             return FALSE;
10049
10050           /* Clear the DF_TEXTREL flag.  It will be set again if we
10051              write out an actual text relocation; we may not, because
10052              at this point we do not know whether e.g. any .eh_frame
10053              absolute relocations have been converted to PC-relative.  */
10054           info->flags &= ~DF_TEXTREL;
10055         }
10056
10057       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
10058         return FALSE;
10059
10060       sreldyn = mips_elf_rel_dyn_section (info, FALSE);
10061       if (htab->is_vxworks)
10062         {
10063           /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
10064              use any of the DT_MIPS_* tags.  */
10065           if (sreldyn && sreldyn->size > 0)
10066             {
10067               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
10068                 return FALSE;
10069
10070               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
10071                 return FALSE;
10072
10073               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
10074                 return FALSE;
10075             }
10076         }
10077       else
10078         {
10079           if (sreldyn && sreldyn->size > 0
10080               && !bfd_is_abs_section (sreldyn->output_section))
10081             {
10082               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
10083                 return FALSE;
10084
10085               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
10086                 return FALSE;
10087
10088               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
10089                 return FALSE;
10090             }
10091
10092           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
10093             return FALSE;
10094
10095           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
10096             return FALSE;
10097
10098           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
10099             return FALSE;
10100
10101           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
10102             return FALSE;
10103
10104           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
10105             return FALSE;
10106
10107           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
10108             return FALSE;
10109
10110           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
10111             return FALSE;
10112
10113           if (IRIX_COMPAT (dynobj) == ict_irix5
10114               && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
10115             return FALSE;
10116
10117           if (IRIX_COMPAT (dynobj) == ict_irix6
10118               && (bfd_get_section_by_name
10119                   (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
10120               && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
10121             return FALSE;
10122         }
10123       if (htab->root.splt->size > 0)
10124         {
10125           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
10126             return FALSE;
10127
10128           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
10129             return FALSE;
10130
10131           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
10132             return FALSE;
10133
10134           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
10135             return FALSE;
10136         }
10137       if (htab->is_vxworks
10138           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
10139         return FALSE;
10140     }
10141
10142   return TRUE;
10143 }
10144 \f
10145 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
10146    Adjust its R_ADDEND field so that it is correct for the output file.
10147    LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
10148    and sections respectively; both use symbol indexes.  */
10149
10150 static void
10151 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
10152                         bfd *input_bfd, Elf_Internal_Sym *local_syms,
10153                         asection **local_sections, Elf_Internal_Rela *rel)
10154 {
10155   unsigned int r_type, r_symndx;
10156   Elf_Internal_Sym *sym;
10157   asection *sec;
10158
10159   if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10160     {
10161       r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10162       if (gprel16_reloc_p (r_type)
10163           || r_type == R_MIPS_GPREL32
10164           || literal_reloc_p (r_type))
10165         {
10166           rel->r_addend += _bfd_get_gp_value (input_bfd);
10167           rel->r_addend -= _bfd_get_gp_value (output_bfd);
10168         }
10169
10170       r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
10171       sym = local_syms + r_symndx;
10172
10173       /* Adjust REL's addend to account for section merging.  */
10174       if (!bfd_link_relocatable (info))
10175         {
10176           sec = local_sections[r_symndx];
10177           _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10178         }
10179
10180       /* This would normally be done by the rela_normal code in elflink.c.  */
10181       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10182         rel->r_addend += local_sections[r_symndx]->output_offset;
10183     }
10184 }
10185
10186 /* Handle relocations against symbols from removed linkonce sections,
10187    or sections discarded by a linker script.  We use this wrapper around
10188    RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
10189    on 64-bit ELF targets.  In this case for any relocation handled, which
10190    always be the first in a triplet, the remaining two have to be processed
10191    together with the first, even if they are R_MIPS_NONE.  It is the symbol
10192    index referred by the first reloc that applies to all the three and the
10193    remaining two never refer to an object symbol.  And it is the final
10194    relocation (the last non-null one) that determines the output field of
10195    the whole relocation so retrieve the corresponding howto structure for
10196    the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
10197
10198    Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
10199    and therefore requires to be pasted in a loop.  It also defines a block
10200    and does not protect any of its arguments, hence the extra brackets.  */
10201
10202 static void
10203 mips_reloc_against_discarded_section (bfd *output_bfd,
10204                                       struct bfd_link_info *info,
10205                                       bfd *input_bfd, asection *input_section,
10206                                       Elf_Internal_Rela **rel,
10207                                       const Elf_Internal_Rela **relend,
10208                                       bfd_boolean rel_reloc,
10209                                       reloc_howto_type *howto,
10210                                       bfd_byte *contents)
10211 {
10212   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10213   int count = bed->s->int_rels_per_ext_rel;
10214   unsigned int r_type;
10215   int i;
10216
10217   for (i = count - 1; i > 0; i--)
10218     {
10219       r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
10220       if (r_type != R_MIPS_NONE)
10221         {
10222           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10223           break;
10224         }
10225     }
10226   do
10227     {
10228        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
10229                                         (*rel), count, (*relend),
10230                                         howto, i, contents);
10231     }
10232   while (0);
10233 }
10234
10235 /* Relocate a MIPS ELF section.  */
10236
10237 bfd_boolean
10238 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
10239                                 bfd *input_bfd, asection *input_section,
10240                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
10241                                 Elf_Internal_Sym *local_syms,
10242                                 asection **local_sections)
10243 {
10244   Elf_Internal_Rela *rel;
10245   const Elf_Internal_Rela *relend;
10246   bfd_vma addend = 0;
10247   bfd_boolean use_saved_addend_p = FALSE;
10248
10249   relend = relocs + input_section->reloc_count;
10250   for (rel = relocs; rel < relend; ++rel)
10251     {
10252       const char *name;
10253       bfd_vma value = 0;
10254       reloc_howto_type *howto;
10255       bfd_boolean cross_mode_jump_p = FALSE;
10256       /* TRUE if the relocation is a RELA relocation, rather than a
10257          REL relocation.  */
10258       bfd_boolean rela_relocation_p = TRUE;
10259       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10260       const char *msg;
10261       unsigned long r_symndx;
10262       asection *sec;
10263       Elf_Internal_Shdr *symtab_hdr;
10264       struct elf_link_hash_entry *h;
10265       bfd_boolean rel_reloc;
10266
10267       rel_reloc = (NEWABI_P (input_bfd)
10268                    && mips_elf_rel_relocation_p (input_bfd, input_section,
10269                                                  relocs, rel));
10270       /* Find the relocation howto for this relocation.  */
10271       howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10272
10273       r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
10274       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
10275       if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10276         {
10277           sec = local_sections[r_symndx];
10278           h = NULL;
10279         }
10280       else
10281         {
10282           unsigned long extsymoff;
10283
10284           extsymoff = 0;
10285           if (!elf_bad_symtab (input_bfd))
10286             extsymoff = symtab_hdr->sh_info;
10287           h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
10288           while (h->root.type == bfd_link_hash_indirect
10289                  || h->root.type == bfd_link_hash_warning)
10290             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10291
10292           sec = NULL;
10293           if (h->root.type == bfd_link_hash_defined
10294               || h->root.type == bfd_link_hash_defweak)
10295             sec = h->root.u.def.section;
10296         }
10297
10298       if (sec != NULL && discarded_section (sec))
10299         {
10300           mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
10301                                                 input_section, &rel, &relend,
10302                                                 rel_reloc, howto, contents);
10303           continue;
10304         }
10305
10306       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
10307         {
10308           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
10309              64-bit code, but make sure all their addresses are in the
10310              lowermost or uppermost 32-bit section of the 64-bit address
10311              space.  Thus, when they use an R_MIPS_64 they mean what is
10312              usually meant by R_MIPS_32, with the exception that the
10313              stored value is sign-extended to 64 bits.  */
10314           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
10315
10316           /* On big-endian systems, we need to lie about the position
10317              of the reloc.  */
10318           if (bfd_big_endian (input_bfd))
10319             rel->r_offset += 4;
10320         }
10321
10322       if (!use_saved_addend_p)
10323         {
10324           /* If these relocations were originally of the REL variety,
10325              we must pull the addend out of the field that will be
10326              relocated.  Otherwise, we simply use the contents of the
10327              RELA relocation.  */
10328           if (mips_elf_rel_relocation_p (input_bfd, input_section,
10329                                          relocs, rel))
10330             {
10331               rela_relocation_p = FALSE;
10332               addend = mips_elf_read_rel_addend (input_bfd, rel,
10333                                                  howto, contents);
10334               if (hi16_reloc_p (r_type)
10335                   || (got16_reloc_p (r_type)
10336                       && mips_elf_local_relocation_p (input_bfd, rel,
10337                                                       local_sections)))
10338                 {
10339                   if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
10340                                                      contents, &addend))
10341                     {
10342                       if (h)
10343                         name = h->root.root.string;
10344                       else
10345                         name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10346                                                  local_syms + r_symndx,
10347                                                  sec);
10348                       _bfd_error_handler
10349                         /* xgettext:c-format */
10350                         (_("%pB: can't find matching LO16 reloc against `%s'"
10351                            " for %s at %#" PRIx64 " in section `%pA'"),
10352                          input_bfd, name,
10353                          howto->name, (uint64_t) rel->r_offset, input_section);
10354                     }
10355                 }
10356               else
10357                 addend <<= howto->rightshift;
10358             }
10359           else
10360             addend = rel->r_addend;
10361           mips_elf_adjust_addend (output_bfd, info, input_bfd,
10362                                   local_syms, local_sections, rel);
10363         }
10364
10365       if (bfd_link_relocatable (info))
10366         {
10367           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
10368               && bfd_big_endian (input_bfd))
10369             rel->r_offset -= 4;
10370
10371           if (!rela_relocation_p && rel->r_addend)
10372             {
10373               addend += rel->r_addend;
10374               if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
10375                 addend = mips_elf_high (addend);
10376               else if (r_type == R_MIPS_HIGHER)
10377                 addend = mips_elf_higher (addend);
10378               else if (r_type == R_MIPS_HIGHEST)
10379                 addend = mips_elf_highest (addend);
10380               else
10381                 addend >>= howto->rightshift;
10382
10383               /* We use the source mask, rather than the destination
10384                  mask because the place to which we are writing will be
10385                  source of the addend in the final link.  */
10386               addend &= howto->src_mask;
10387
10388               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10389                 /* See the comment above about using R_MIPS_64 in the 32-bit
10390                    ABI.  Here, we need to update the addend.  It would be
10391                    possible to get away with just using the R_MIPS_32 reloc
10392                    but for endianness.  */
10393                 {
10394                   bfd_vma sign_bits;
10395                   bfd_vma low_bits;
10396                   bfd_vma high_bits;
10397
10398                   if (addend & ((bfd_vma) 1 << 31))
10399 #ifdef BFD64
10400                     sign_bits = ((bfd_vma) 1 << 32) - 1;
10401 #else
10402                     sign_bits = -1;
10403 #endif
10404                   else
10405                     sign_bits = 0;
10406
10407                   /* If we don't know that we have a 64-bit type,
10408                      do two separate stores.  */
10409                   if (bfd_big_endian (input_bfd))
10410                     {
10411                       /* Store the sign-bits (which are most significant)
10412                          first.  */
10413                       low_bits = sign_bits;
10414                       high_bits = addend;
10415                     }
10416                   else
10417                     {
10418                       low_bits = addend;
10419                       high_bits = sign_bits;
10420                     }
10421                   bfd_put_32 (input_bfd, low_bits,
10422                               contents + rel->r_offset);
10423                   bfd_put_32 (input_bfd, high_bits,
10424                               contents + rel->r_offset + 4);
10425                   continue;
10426                 }
10427
10428               if (! mips_elf_perform_relocation (info, howto, rel, addend,
10429                                                  input_bfd, input_section,
10430                                                  contents, FALSE))
10431                 return FALSE;
10432             }
10433
10434           /* Go on to the next relocation.  */
10435           continue;
10436         }
10437
10438       /* In the N32 and 64-bit ABIs there may be multiple consecutive
10439          relocations for the same offset.  In that case we are
10440          supposed to treat the output of each relocation as the addend
10441          for the next.  */
10442       if (rel + 1 < relend
10443           && rel->r_offset == rel[1].r_offset
10444           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
10445         use_saved_addend_p = TRUE;
10446       else
10447         use_saved_addend_p = FALSE;
10448
10449       /* Figure out what value we are supposed to relocate.  */
10450       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
10451                                              input_section, contents,
10452                                              info, rel, addend, howto,
10453                                              local_syms, local_sections,
10454                                              &value, &name, &cross_mode_jump_p,
10455                                              use_saved_addend_p))
10456         {
10457         case bfd_reloc_continue:
10458           /* There's nothing to do.  */
10459           continue;
10460
10461         case bfd_reloc_undefined:
10462           /* mips_elf_calculate_relocation already called the
10463              undefined_symbol callback.  There's no real point in
10464              trying to perform the relocation at this point, so we
10465              just skip ahead to the next relocation.  */
10466           continue;
10467
10468         case bfd_reloc_notsupported:
10469           msg = _("internal error: unsupported relocation error");
10470           info->callbacks->warning
10471             (info, msg, name, input_bfd, input_section, rel->r_offset);
10472           return FALSE;
10473
10474         case bfd_reloc_overflow:
10475           if (use_saved_addend_p)
10476             /* Ignore overflow until we reach the last relocation for
10477                a given location.  */
10478             ;
10479           else
10480             {
10481               struct mips_elf_link_hash_table *htab;
10482
10483               htab = mips_elf_hash_table (info);
10484               BFD_ASSERT (htab != NULL);
10485               BFD_ASSERT (name != NULL);
10486               if (!htab->small_data_overflow_reported
10487                   && (gprel16_reloc_p (howto->type)
10488                       || literal_reloc_p (howto->type)))
10489                 {
10490                   msg = _("small-data section exceeds 64KB;"
10491                           " lower small-data size limit (see option -G)");
10492
10493                   htab->small_data_overflow_reported = TRUE;
10494                   (*info->callbacks->einfo) ("%P: %s\n", msg);
10495                 }
10496               (*info->callbacks->reloc_overflow)
10497                 (info, NULL, name, howto->name, (bfd_vma) 0,
10498                  input_bfd, input_section, rel->r_offset);
10499             }
10500           break;
10501
10502         case bfd_reloc_ok:
10503           break;
10504
10505         case bfd_reloc_outofrange:
10506           msg = NULL;
10507           if (jal_reloc_p (howto->type))
10508             msg = (cross_mode_jump_p
10509                    ? _("cannot convert a jump to JALX "
10510                        "for a non-word-aligned address")
10511                    : (howto->type == R_MIPS16_26
10512                       ? _("jump to a non-word-aligned address")
10513                       : _("jump to a non-instruction-aligned address")));
10514           else if (b_reloc_p (howto->type))
10515             msg = (cross_mode_jump_p
10516                    ? _("cannot convert a branch to JALX "
10517                        "for a non-word-aligned address")
10518                    : _("branch to a non-instruction-aligned address"));
10519           else if (aligned_pcrel_reloc_p (howto->type))
10520             msg = _("PC-relative load from unaligned address");
10521           if (msg)
10522             {
10523               info->callbacks->einfo
10524                 ("%X%H: %s\n", input_bfd, input_section, rel->r_offset, msg);
10525               break;
10526             }
10527           /* Fall through.  */
10528
10529         default:
10530           abort ();
10531           break;
10532         }
10533
10534       /* If we've got another relocation for the address, keep going
10535          until we reach the last one.  */
10536       if (use_saved_addend_p)
10537         {
10538           addend = value;
10539           continue;
10540         }
10541
10542       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10543         /* See the comment above about using R_MIPS_64 in the 32-bit
10544            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
10545            that calculated the right value.  Now, however, we
10546            sign-extend the 32-bit result to 64-bits, and store it as a
10547            64-bit value.  We are especially generous here in that we
10548            go to extreme lengths to support this usage on systems with
10549            only a 32-bit VMA.  */
10550         {
10551           bfd_vma sign_bits;
10552           bfd_vma low_bits;
10553           bfd_vma high_bits;
10554
10555           if (value & ((bfd_vma) 1 << 31))
10556 #ifdef BFD64
10557             sign_bits = ((bfd_vma) 1 << 32) - 1;
10558 #else
10559             sign_bits = -1;
10560 #endif
10561           else
10562             sign_bits = 0;
10563
10564           /* If we don't know that we have a 64-bit type,
10565              do two separate stores.  */
10566           if (bfd_big_endian (input_bfd))
10567             {
10568               /* Undo what we did above.  */
10569               rel->r_offset -= 4;
10570               /* Store the sign-bits (which are most significant)
10571                  first.  */
10572               low_bits = sign_bits;
10573               high_bits = value;
10574             }
10575           else
10576             {
10577               low_bits = value;
10578               high_bits = sign_bits;
10579             }
10580           bfd_put_32 (input_bfd, low_bits,
10581                       contents + rel->r_offset);
10582           bfd_put_32 (input_bfd, high_bits,
10583                       contents + rel->r_offset + 4);
10584           continue;
10585         }
10586
10587       /* Actually perform the relocation.  */
10588       if (! mips_elf_perform_relocation (info, howto, rel, value,
10589                                          input_bfd, input_section,
10590                                          contents, cross_mode_jump_p))
10591         return FALSE;
10592     }
10593
10594   return TRUE;
10595 }
10596 \f
10597 /* A function that iterates over each entry in la25_stubs and fills
10598    in the code for each one.  DATA points to a mips_htab_traverse_info.  */
10599
10600 static int
10601 mips_elf_create_la25_stub (void **slot, void *data)
10602 {
10603   struct mips_htab_traverse_info *hti;
10604   struct mips_elf_link_hash_table *htab;
10605   struct mips_elf_la25_stub *stub;
10606   asection *s;
10607   bfd_byte *loc;
10608   bfd_vma offset, target, target_high, target_low;
10609
10610   stub = (struct mips_elf_la25_stub *) *slot;
10611   hti = (struct mips_htab_traverse_info *) data;
10612   htab = mips_elf_hash_table (hti->info);
10613   BFD_ASSERT (htab != NULL);
10614
10615   /* Create the section contents, if we haven't already.  */
10616   s = stub->stub_section;
10617   loc = s->contents;
10618   if (loc == NULL)
10619     {
10620       loc = bfd_malloc (s->size);
10621       if (loc == NULL)
10622         {
10623           hti->error = TRUE;
10624           return FALSE;
10625         }
10626       s->contents = loc;
10627     }
10628
10629   /* Work out where in the section this stub should go.  */
10630   offset = stub->offset;
10631
10632   /* Work out the target address.  */
10633   target = mips_elf_get_la25_target (stub, &s);
10634   target += s->output_section->vma + s->output_offset;
10635
10636   target_high = ((target + 0x8000) >> 16) & 0xffff;
10637   target_low = (target & 0xffff);
10638
10639   if (stub->stub_section != htab->strampoline)
10640     {
10641       /* This is a simple LUI/ADDIU stub.  Zero out the beginning
10642          of the section and write the two instructions at the end.  */
10643       memset (loc, 0, offset);
10644       loc += offset;
10645       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10646         {
10647           bfd_put_micromips_32 (hti->output_bfd,
10648                                 LA25_LUI_MICROMIPS (target_high),
10649                                 loc);
10650           bfd_put_micromips_32 (hti->output_bfd,
10651                                 LA25_ADDIU_MICROMIPS (target_low),
10652                                 loc + 4);
10653         }
10654       else
10655         {
10656           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10657           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
10658         }
10659     }
10660   else
10661     {
10662       /* This is trampoline.  */
10663       loc += offset;
10664       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10665         {
10666           bfd_put_micromips_32 (hti->output_bfd,
10667                                 LA25_LUI_MICROMIPS (target_high), loc);
10668           bfd_put_micromips_32 (hti->output_bfd,
10669                                 LA25_J_MICROMIPS (target), loc + 4);
10670           bfd_put_micromips_32 (hti->output_bfd,
10671                                 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
10672           bfd_put_32 (hti->output_bfd, 0, loc + 12);
10673         }
10674       else
10675         {
10676           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10677           bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
10678           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
10679           bfd_put_32 (hti->output_bfd, 0, loc + 12);
10680         }
10681     }
10682   return TRUE;
10683 }
10684
10685 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10686    adjust it appropriately now.  */
10687
10688 static void
10689 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
10690                                       const char *name, Elf_Internal_Sym *sym)
10691 {
10692   /* The linker script takes care of providing names and values for
10693      these, but we must place them into the right sections.  */
10694   static const char* const text_section_symbols[] = {
10695     "_ftext",
10696     "_etext",
10697     "__dso_displacement",
10698     "__elf_header",
10699     "__program_header_table",
10700     NULL
10701   };
10702
10703   static const char* const data_section_symbols[] = {
10704     "_fdata",
10705     "_edata",
10706     "_end",
10707     "_fbss",
10708     NULL
10709   };
10710
10711   const char* const *p;
10712   int i;
10713
10714   for (i = 0; i < 2; ++i)
10715     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
10716          *p;
10717          ++p)
10718       if (strcmp (*p, name) == 0)
10719         {
10720           /* All of these symbols are given type STT_SECTION by the
10721              IRIX6 linker.  */
10722           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10723           sym->st_other = STO_PROTECTED;
10724
10725           /* The IRIX linker puts these symbols in special sections.  */
10726           if (i == 0)
10727             sym->st_shndx = SHN_MIPS_TEXT;
10728           else
10729             sym->st_shndx = SHN_MIPS_DATA;
10730
10731           break;
10732         }
10733 }
10734
10735 /* Finish up dynamic symbol handling.  We set the contents of various
10736    dynamic sections here.  */
10737
10738 bfd_boolean
10739 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
10740                                      struct bfd_link_info *info,
10741                                      struct elf_link_hash_entry *h,
10742                                      Elf_Internal_Sym *sym)
10743 {
10744   bfd *dynobj;
10745   asection *sgot;
10746   struct mips_got_info *g, *gg;
10747   const char *name;
10748   int idx;
10749   struct mips_elf_link_hash_table *htab;
10750   struct mips_elf_link_hash_entry *hmips;
10751
10752   htab = mips_elf_hash_table (info);
10753   BFD_ASSERT (htab != NULL);
10754   dynobj = elf_hash_table (info)->dynobj;
10755   hmips = (struct mips_elf_link_hash_entry *) h;
10756
10757   BFD_ASSERT (!htab->is_vxworks);
10758
10759   if (h->plt.plist != NULL
10760       && (h->plt.plist->mips_offset != MINUS_ONE
10761           || h->plt.plist->comp_offset != MINUS_ONE))
10762     {
10763       /* We've decided to create a PLT entry for this symbol.  */
10764       bfd_byte *loc;
10765       bfd_vma header_address, got_address;
10766       bfd_vma got_address_high, got_address_low, load;
10767       bfd_vma got_index;
10768       bfd_vma isa_bit;
10769
10770       got_index = h->plt.plist->gotplt_index;
10771
10772       BFD_ASSERT (htab->use_plts_and_copy_relocs);
10773       BFD_ASSERT (h->dynindx != -1);
10774       BFD_ASSERT (htab->root.splt != NULL);
10775       BFD_ASSERT (got_index != MINUS_ONE);
10776       BFD_ASSERT (!h->def_regular);
10777
10778       /* Calculate the address of the PLT header.  */
10779       isa_bit = htab->plt_header_is_comp;
10780       header_address = (htab->root.splt->output_section->vma
10781                         + htab->root.splt->output_offset + isa_bit);
10782
10783       /* Calculate the address of the .got.plt entry.  */
10784       got_address = (htab->root.sgotplt->output_section->vma
10785                      + htab->root.sgotplt->output_offset
10786                      + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10787
10788       got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10789       got_address_low = got_address & 0xffff;
10790
10791       /* The PLT sequence is not safe for N64 if .got.plt entry's address
10792          cannot be loaded in two instructions.  */
10793       if (ABI_64_P (output_bfd)
10794           && ((got_address + 0x80008000) & ~(bfd_vma) 0xffffffff) != 0)
10795         {
10796           _bfd_error_handler
10797             /* xgettext:c-format */
10798             (_("%pB: `%pA' entry VMA of %#" PRIx64 " outside the 32-bit range "
10799                "supported; consider using `-Ttext-segment=...'"),
10800              output_bfd,
10801              htab->root.sgotplt->output_section,
10802              (int64_t) got_address);
10803           bfd_set_error (bfd_error_no_error);
10804           return FALSE;
10805         }
10806
10807       /* Initially point the .got.plt entry at the PLT header.  */
10808       loc = (htab->root.sgotplt->contents
10809              + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10810       if (ABI_64_P (output_bfd))
10811         bfd_put_64 (output_bfd, header_address, loc);
10812       else
10813         bfd_put_32 (output_bfd, header_address, loc);
10814
10815       /* Now handle the PLT itself.  First the standard entry (the order
10816          does not matter, we just have to pick one).  */
10817       if (h->plt.plist->mips_offset != MINUS_ONE)
10818         {
10819           const bfd_vma *plt_entry;
10820           bfd_vma plt_offset;
10821
10822           plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
10823
10824           BFD_ASSERT (plt_offset <= htab->root.splt->size);
10825
10826           /* Find out where the .plt entry should go.  */
10827           loc = htab->root.splt->contents + plt_offset;
10828
10829           /* Pick the load opcode.  */
10830           load = MIPS_ELF_LOAD_WORD (output_bfd);
10831
10832           /* Fill in the PLT entry itself.  */
10833
10834           if (MIPSR6_P (output_bfd))
10835             plt_entry = mipsr6_exec_plt_entry;
10836           else
10837             plt_entry = mips_exec_plt_entry;
10838           bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
10839           bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load,
10840                       loc + 4);
10841
10842           if (! LOAD_INTERLOCKS_P (output_bfd))
10843             {
10844               bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
10845               bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10846             }
10847           else
10848             {
10849               bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
10850               bfd_put_32 (output_bfd, plt_entry[2] | got_address_low,
10851                           loc + 12);
10852             }
10853         }
10854
10855       /* Now the compressed entry.  They come after any standard ones.  */
10856       if (h->plt.plist->comp_offset != MINUS_ONE)
10857         {
10858           bfd_vma plt_offset;
10859
10860           plt_offset = (htab->plt_header_size + htab->plt_mips_offset
10861                         + h->plt.plist->comp_offset);
10862
10863           BFD_ASSERT (plt_offset <= htab->root.splt->size);
10864
10865           /* Find out where the .plt entry should go.  */
10866           loc = htab->root.splt->contents + plt_offset;
10867
10868           /* Fill in the PLT entry itself.  */
10869           if (!MICROMIPS_P (output_bfd))
10870             {
10871               const bfd_vma *plt_entry = mips16_o32_exec_plt_entry;
10872
10873               bfd_put_16 (output_bfd, plt_entry[0], loc);
10874               bfd_put_16 (output_bfd, plt_entry[1], loc + 2);
10875               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10876               bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10877               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10878               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10879               bfd_put_32 (output_bfd, got_address, loc + 12);
10880             }
10881           else if (htab->insn32)
10882             {
10883               const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry;
10884
10885               bfd_put_16 (output_bfd, plt_entry[0], loc);
10886               bfd_put_16 (output_bfd, got_address_high, loc + 2);
10887               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10888               bfd_put_16 (output_bfd, got_address_low, loc + 6);
10889               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10890               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10891               bfd_put_16 (output_bfd, plt_entry[6], loc + 12);
10892               bfd_put_16 (output_bfd, got_address_low, loc + 14);
10893             }
10894           else
10895             {
10896               const bfd_vma *plt_entry = micromips_o32_exec_plt_entry;
10897               bfd_signed_vma gotpc_offset;
10898               bfd_vma loc_address;
10899
10900               BFD_ASSERT (got_address % 4 == 0);
10901
10902               loc_address = (htab->root.splt->output_section->vma
10903                              + htab->root.splt->output_offset + plt_offset);
10904               gotpc_offset = got_address - ((loc_address | 3) ^ 3);
10905
10906               /* ADDIUPC has a span of +/-16MB, check we're in range.  */
10907               if (gotpc_offset + 0x1000000 >= 0x2000000)
10908                 {
10909                   _bfd_error_handler
10910                     /* xgettext:c-format */
10911                     (_("%pB: `%pA' offset of %" PRId64 " from `%pA' "
10912                        "beyond the range of ADDIUPC"),
10913                      output_bfd,
10914                      htab->root.sgotplt->output_section,
10915                      (int64_t) gotpc_offset,
10916                      htab->root.splt->output_section);
10917                   bfd_set_error (bfd_error_no_error);
10918                   return FALSE;
10919                 }
10920               bfd_put_16 (output_bfd,
10921                           plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
10922               bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
10923               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10924               bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10925               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10926               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10927             }
10928         }
10929
10930       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
10931       mips_elf_output_dynamic_relocation (output_bfd, htab->root.srelplt,
10932                                           got_index - 2, h->dynindx,
10933                                           R_MIPS_JUMP_SLOT, got_address);
10934
10935       /* We distinguish between PLT entries and lazy-binding stubs by
10936          giving the former an st_other value of STO_MIPS_PLT.  Set the
10937          flag and leave the value if there are any relocations in the
10938          binary where pointer equality matters.  */
10939       sym->st_shndx = SHN_UNDEF;
10940       if (h->pointer_equality_needed)
10941         sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other);
10942       else
10943         {
10944           sym->st_value = 0;
10945           sym->st_other = 0;
10946         }
10947     }
10948
10949   if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE)
10950     {
10951       /* We've decided to create a lazy-binding stub.  */
10952       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
10953       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
10954       bfd_vma stub_size = htab->function_stub_size;
10955       bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
10956       bfd_vma isa_bit = micromips_p;
10957       bfd_vma stub_big_size;
10958
10959       if (!micromips_p)
10960         stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE;
10961       else if (htab->insn32)
10962         stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE;
10963       else
10964         stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE;
10965
10966       /* This symbol has a stub.  Set it up.  */
10967
10968       BFD_ASSERT (h->dynindx != -1);
10969
10970       BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff);
10971
10972       /* Values up to 2^31 - 1 are allowed.  Larger values would cause
10973          sign extension at runtime in the stub, resulting in a negative
10974          index value.  */
10975       if (h->dynindx & ~0x7fffffff)
10976         return FALSE;
10977
10978       /* Fill the stub.  */
10979       if (micromips_p)
10980         {
10981           idx = 0;
10982           bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd),
10983                                 stub + idx);
10984           idx += 4;
10985           if (htab->insn32)
10986             {
10987               bfd_put_micromips_32 (output_bfd,
10988                                     STUB_MOVE32_MICROMIPS, stub + idx);
10989               idx += 4;
10990             }
10991           else
10992             {
10993               bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx);
10994               idx += 2;
10995             }
10996           if (stub_size == stub_big_size)
10997             {
10998               long dynindx_hi = (h->dynindx >> 16) & 0x7fff;
10999
11000               bfd_put_micromips_32 (output_bfd,
11001                                     STUB_LUI_MICROMIPS (dynindx_hi),
11002                                     stub + idx);
11003               idx += 4;
11004             }
11005           if (htab->insn32)
11006             {
11007               bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS,
11008                                     stub + idx);
11009               idx += 4;
11010             }
11011           else
11012             {
11013               bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx);
11014               idx += 2;
11015             }
11016
11017           /* If a large stub is not required and sign extension is not a
11018              problem, then use legacy code in the stub.  */
11019           if (stub_size == stub_big_size)
11020             bfd_put_micromips_32 (output_bfd,
11021                                   STUB_ORI_MICROMIPS (h->dynindx & 0xffff),
11022                                   stub + idx);
11023           else if (h->dynindx & ~0x7fff)
11024             bfd_put_micromips_32 (output_bfd,
11025                                   STUB_LI16U_MICROMIPS (h->dynindx & 0xffff),
11026                                   stub + idx);
11027           else
11028             bfd_put_micromips_32 (output_bfd,
11029                                   STUB_LI16S_MICROMIPS (output_bfd,
11030                                                         h->dynindx),
11031                                   stub + idx);
11032         }
11033       else
11034         {
11035           idx = 0;
11036           bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
11037           idx += 4;
11038           bfd_put_32 (output_bfd, STUB_MOVE, stub + idx);
11039           idx += 4;
11040           if (stub_size == stub_big_size)
11041             {
11042               bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
11043                           stub + idx);
11044               idx += 4;
11045             }
11046           bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
11047           idx += 4;
11048
11049           /* If a large stub is not required and sign extension is not a
11050              problem, then use legacy code in the stub.  */
11051           if (stub_size == stub_big_size)
11052             bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff),
11053                         stub + idx);
11054           else if (h->dynindx & ~0x7fff)
11055             bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff),
11056                         stub + idx);
11057           else
11058             bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
11059                         stub + idx);
11060         }
11061
11062       BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size);
11063       memcpy (htab->sstubs->contents + h->plt.plist->stub_offset,
11064               stub, stub_size);
11065
11066       /* Mark the symbol as undefined.  stub_offset != -1 occurs
11067          only for the referenced symbol.  */
11068       sym->st_shndx = SHN_UNDEF;
11069
11070       /* The run-time linker uses the st_value field of the symbol
11071          to reset the global offset table entry for this external
11072          to its stub address when unlinking a shared object.  */
11073       sym->st_value = (htab->sstubs->output_section->vma
11074                        + htab->sstubs->output_offset
11075                        + h->plt.plist->stub_offset
11076                        + isa_bit);
11077       sym->st_other = other;
11078     }
11079
11080   /* If we have a MIPS16 function with a stub, the dynamic symbol must
11081      refer to the stub, since only the stub uses the standard calling
11082      conventions.  */
11083   if (h->dynindx != -1 && hmips->fn_stub != NULL)
11084     {
11085       BFD_ASSERT (hmips->need_fn_stub);
11086       sym->st_value = (hmips->fn_stub->output_section->vma
11087                        + hmips->fn_stub->output_offset);
11088       sym->st_size = hmips->fn_stub->size;
11089       sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
11090     }
11091
11092   BFD_ASSERT (h->dynindx != -1
11093               || h->forced_local);
11094
11095   sgot = htab->root.sgot;
11096   g = htab->got_info;
11097   BFD_ASSERT (g != NULL);
11098
11099   /* Run through the global symbol table, creating GOT entries for all
11100      the symbols that need them.  */
11101   if (hmips->global_got_area != GGA_NONE)
11102     {
11103       bfd_vma offset;
11104       bfd_vma value;
11105
11106       value = sym->st_value;
11107       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11108       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
11109     }
11110
11111   if (hmips->global_got_area != GGA_NONE && g->next)
11112     {
11113       struct mips_got_entry e, *p;
11114       bfd_vma entry;
11115       bfd_vma offset;
11116
11117       gg = g;
11118
11119       e.abfd = output_bfd;
11120       e.symndx = -1;
11121       e.d.h = hmips;
11122       e.tls_type = GOT_TLS_NONE;
11123
11124       for (g = g->next; g->next != gg; g = g->next)
11125         {
11126           if (g->got_entries
11127               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
11128                                                            &e)))
11129             {
11130               offset = p->gotidx;
11131               BFD_ASSERT (offset > 0 && offset < htab->root.sgot->size);
11132               if (bfd_link_pic (info)
11133                   || (elf_hash_table (info)->dynamic_sections_created
11134                       && p->d.h != NULL
11135                       && p->d.h->root.def_dynamic
11136                       && !p->d.h->root.def_regular))
11137                 {
11138                   /* Create an R_MIPS_REL32 relocation for this entry.  Due to
11139                      the various compatibility problems, it's easier to mock
11140                      up an R_MIPS_32 or R_MIPS_64 relocation and leave
11141                      mips_elf_create_dynamic_relocation to calculate the
11142                      appropriate addend.  */
11143                   Elf_Internal_Rela rel[3];
11144
11145                   memset (rel, 0, sizeof (rel));
11146                   if (ABI_64_P (output_bfd))
11147                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
11148                   else
11149                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
11150                   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
11151
11152                   entry = 0;
11153                   if (! (mips_elf_create_dynamic_relocation
11154                          (output_bfd, info, rel,
11155                           e.d.h, NULL, sym->st_value, &entry, sgot)))
11156                     return FALSE;
11157                 }
11158               else
11159                 entry = sym->st_value;
11160               MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
11161             }
11162         }
11163     }
11164
11165   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
11166   name = h->root.root.string;
11167   if (h == elf_hash_table (info)->hdynamic
11168       || h == elf_hash_table (info)->hgot)
11169     sym->st_shndx = SHN_ABS;
11170   else if (strcmp (name, "_DYNAMIC_LINK") == 0
11171            || strcmp (name, "_DYNAMIC_LINKING") == 0)
11172     {
11173       sym->st_shndx = SHN_ABS;
11174       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11175       sym->st_value = 1;
11176     }
11177   else if (SGI_COMPAT (output_bfd))
11178     {
11179       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
11180           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
11181         {
11182           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11183           sym->st_other = STO_PROTECTED;
11184           sym->st_value = 0;
11185           sym->st_shndx = SHN_MIPS_DATA;
11186         }
11187       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
11188         {
11189           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11190           sym->st_other = STO_PROTECTED;
11191           sym->st_value = mips_elf_hash_table (info)->procedure_count;
11192           sym->st_shndx = SHN_ABS;
11193         }
11194       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
11195         {
11196           if (h->type == STT_FUNC)
11197             sym->st_shndx = SHN_MIPS_TEXT;
11198           else if (h->type == STT_OBJECT)
11199             sym->st_shndx = SHN_MIPS_DATA;
11200         }
11201     }
11202
11203   /* Emit a copy reloc, if needed.  */
11204   if (h->needs_copy)
11205     {
11206       asection *s;
11207       bfd_vma symval;
11208
11209       BFD_ASSERT (h->dynindx != -1);
11210       BFD_ASSERT (htab->use_plts_and_copy_relocs);
11211
11212       s = mips_elf_rel_dyn_section (info, FALSE);
11213       symval = (h->root.u.def.section->output_section->vma
11214                 + h->root.u.def.section->output_offset
11215                 + h->root.u.def.value);
11216       mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
11217                                           h->dynindx, R_MIPS_COPY, symval);
11218     }
11219
11220   /* Handle the IRIX6-specific symbols.  */
11221   if (IRIX_COMPAT (output_bfd) == ict_irix6)
11222     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
11223
11224   /* Keep dynamic compressed symbols odd.  This allows the dynamic linker
11225      to treat compressed symbols like any other.  */
11226   if (ELF_ST_IS_MIPS16 (sym->st_other))
11227     {
11228       BFD_ASSERT (sym->st_value & 1);
11229       sym->st_other -= STO_MIPS16;
11230     }
11231   else if (ELF_ST_IS_MICROMIPS (sym->st_other))
11232     {
11233       BFD_ASSERT (sym->st_value & 1);
11234       sym->st_other -= STO_MICROMIPS;
11235     }
11236
11237   return TRUE;
11238 }
11239
11240 /* Likewise, for VxWorks.  */
11241
11242 bfd_boolean
11243 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
11244                                          struct bfd_link_info *info,
11245                                          struct elf_link_hash_entry *h,
11246                                          Elf_Internal_Sym *sym)
11247 {
11248   bfd *dynobj;
11249   asection *sgot;
11250   struct mips_got_info *g;
11251   struct mips_elf_link_hash_table *htab;
11252   struct mips_elf_link_hash_entry *hmips;
11253
11254   htab = mips_elf_hash_table (info);
11255   BFD_ASSERT (htab != NULL);
11256   dynobj = elf_hash_table (info)->dynobj;
11257   hmips = (struct mips_elf_link_hash_entry *) h;
11258
11259   if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE)
11260     {
11261       bfd_byte *loc;
11262       bfd_vma plt_address, got_address, got_offset, branch_offset;
11263       Elf_Internal_Rela rel;
11264       static const bfd_vma *plt_entry;
11265       bfd_vma gotplt_index;
11266       bfd_vma plt_offset;
11267
11268       plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
11269       gotplt_index = h->plt.plist->gotplt_index;
11270
11271       BFD_ASSERT (h->dynindx != -1);
11272       BFD_ASSERT (htab->root.splt != NULL);
11273       BFD_ASSERT (gotplt_index != MINUS_ONE);
11274       BFD_ASSERT (plt_offset <= htab->root.splt->size);
11275
11276       /* Calculate the address of the .plt entry.  */
11277       plt_address = (htab->root.splt->output_section->vma
11278                      + htab->root.splt->output_offset
11279                      + plt_offset);
11280
11281       /* Calculate the address of the .got.plt entry.  */
11282       got_address = (htab->root.sgotplt->output_section->vma
11283                      + htab->root.sgotplt->output_offset
11284                      + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd));
11285
11286       /* Calculate the offset of the .got.plt entry from
11287          _GLOBAL_OFFSET_TABLE_.  */
11288       got_offset = mips_elf_gotplt_index (info, h);
11289
11290       /* Calculate the offset for the branch at the start of the PLT
11291          entry.  The branch jumps to the beginning of .plt.  */
11292       branch_offset = -(plt_offset / 4 + 1) & 0xffff;
11293
11294       /* Fill in the initial value of the .got.plt entry.  */
11295       bfd_put_32 (output_bfd, plt_address,
11296                   (htab->root.sgotplt->contents
11297                    + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)));
11298
11299       /* Find out where the .plt entry should go.  */
11300       loc = htab->root.splt->contents + plt_offset;
11301
11302       if (bfd_link_pic (info))
11303         {
11304           plt_entry = mips_vxworks_shared_plt_entry;
11305           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11306           bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11307         }
11308       else
11309         {
11310           bfd_vma got_address_high, got_address_low;
11311
11312           plt_entry = mips_vxworks_exec_plt_entry;
11313           got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
11314           got_address_low = got_address & 0xffff;
11315
11316           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11317           bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11318           bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
11319           bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
11320           bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11321           bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11322           bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11323           bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11324
11325           loc = (htab->srelplt2->contents
11326                  + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela));
11327
11328           /* Emit a relocation for the .got.plt entry.  */
11329           rel.r_offset = got_address;
11330           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11331           rel.r_addend = plt_offset;
11332           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11333
11334           /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
11335           loc += sizeof (Elf32_External_Rela);
11336           rel.r_offset = plt_address + 8;
11337           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11338           rel.r_addend = got_offset;
11339           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11340
11341           /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
11342           loc += sizeof (Elf32_External_Rela);
11343           rel.r_offset += 4;
11344           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11345           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11346         }
11347
11348       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
11349       loc = (htab->root.srelplt->contents
11350              + gotplt_index * sizeof (Elf32_External_Rela));
11351       rel.r_offset = got_address;
11352       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
11353       rel.r_addend = 0;
11354       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11355
11356       if (!h->def_regular)
11357         sym->st_shndx = SHN_UNDEF;
11358     }
11359
11360   BFD_ASSERT (h->dynindx != -1 || h->forced_local);
11361
11362   sgot = htab->root.sgot;
11363   g = htab->got_info;
11364   BFD_ASSERT (g != NULL);
11365
11366   /* See if this symbol has an entry in the GOT.  */
11367   if (hmips->global_got_area != GGA_NONE)
11368     {
11369       bfd_vma offset;
11370       Elf_Internal_Rela outrel;
11371       bfd_byte *loc;
11372       asection *s;
11373
11374       /* Install the symbol value in the GOT.   */
11375       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11376       MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
11377
11378       /* Add a dynamic relocation for it.  */
11379       s = mips_elf_rel_dyn_section (info, FALSE);
11380       loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
11381       outrel.r_offset = (sgot->output_section->vma
11382                          + sgot->output_offset
11383                          + offset);
11384       outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
11385       outrel.r_addend = 0;
11386       bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
11387     }
11388
11389   /* Emit a copy reloc, if needed.  */
11390   if (h->needs_copy)
11391     {
11392       Elf_Internal_Rela rel;
11393       asection *srel;
11394       bfd_byte *loc;
11395
11396       BFD_ASSERT (h->dynindx != -1);
11397
11398       rel.r_offset = (h->root.u.def.section->output_section->vma
11399                       + h->root.u.def.section->output_offset
11400                       + h->root.u.def.value);
11401       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
11402       rel.r_addend = 0;
11403       if (h->root.u.def.section == htab->root.sdynrelro)
11404         srel = htab->root.sreldynrelro;
11405       else
11406         srel = htab->root.srelbss;
11407       loc = srel->contents + srel->reloc_count * sizeof (Elf32_External_Rela);
11408       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11409       ++srel->reloc_count;
11410     }
11411
11412   /* If this is a mips16/microMIPS symbol, force the value to be even.  */
11413   if (ELF_ST_IS_COMPRESSED (sym->st_other))
11414     sym->st_value &= ~1;
11415
11416   return TRUE;
11417 }
11418
11419 /* Write out a plt0 entry to the beginning of .plt.  */
11420
11421 static bfd_boolean
11422 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11423 {
11424   bfd_byte *loc;
11425   bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
11426   static const bfd_vma *plt_entry;
11427   struct mips_elf_link_hash_table *htab;
11428
11429   htab = mips_elf_hash_table (info);
11430   BFD_ASSERT (htab != NULL);
11431
11432   if (ABI_64_P (output_bfd))
11433     plt_entry = mips_n64_exec_plt0_entry;
11434   else if (ABI_N32_P (output_bfd))
11435     plt_entry = mips_n32_exec_plt0_entry;
11436   else if (!htab->plt_header_is_comp)
11437     plt_entry = mips_o32_exec_plt0_entry;
11438   else if (htab->insn32)
11439     plt_entry = micromips_insn32_o32_exec_plt0_entry;
11440   else
11441     plt_entry = micromips_o32_exec_plt0_entry;
11442
11443   /* Calculate the value of .got.plt.  */
11444   gotplt_value = (htab->root.sgotplt->output_section->vma
11445                   + htab->root.sgotplt->output_offset);
11446   gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
11447   gotplt_value_low = gotplt_value & 0xffff;
11448
11449   /* The PLT sequence is not safe for N64 if .got.plt's address can
11450      not be loaded in two instructions.  */
11451   if (ABI_64_P (output_bfd)
11452       && ((gotplt_value + 0x80008000) & ~(bfd_vma) 0xffffffff) != 0)
11453     {
11454       _bfd_error_handler
11455         /* xgettext:c-format */
11456         (_("%pB: `%pA' start VMA of %#" PRIx64 " outside the 32-bit range "
11457            "supported; consider using `-Ttext-segment=...'"),
11458          output_bfd,
11459          htab->root.sgotplt->output_section,
11460          (int64_t) gotplt_value);
11461       bfd_set_error (bfd_error_no_error);
11462       return FALSE;
11463     }
11464
11465   /* Install the PLT header.  */
11466   loc = htab->root.splt->contents;
11467   if (plt_entry == micromips_o32_exec_plt0_entry)
11468     {
11469       bfd_vma gotpc_offset;
11470       bfd_vma loc_address;
11471       size_t i;
11472
11473       BFD_ASSERT (gotplt_value % 4 == 0);
11474
11475       loc_address = (htab->root.splt->output_section->vma
11476                      + htab->root.splt->output_offset);
11477       gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3);
11478
11479       /* ADDIUPC has a span of +/-16MB, check we're in range.  */
11480       if (gotpc_offset + 0x1000000 >= 0x2000000)
11481         {
11482           _bfd_error_handler
11483             /* xgettext:c-format */
11484             (_("%pB: `%pA' offset of %" PRId64 " from `%pA' "
11485                "beyond the range of ADDIUPC"),
11486              output_bfd,
11487              htab->root.sgotplt->output_section,
11488              (int64_t) gotpc_offset,
11489              htab->root.splt->output_section);
11490           bfd_set_error (bfd_error_no_error);
11491           return FALSE;
11492         }
11493       bfd_put_16 (output_bfd,
11494                   plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
11495       bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
11496       for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++)
11497         bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11498     }
11499   else if (plt_entry == micromips_insn32_o32_exec_plt0_entry)
11500     {
11501       size_t i;
11502
11503       bfd_put_16 (output_bfd, plt_entry[0], loc);
11504       bfd_put_16 (output_bfd, gotplt_value_high, loc + 2);
11505       bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
11506       bfd_put_16 (output_bfd, gotplt_value_low, loc + 6);
11507       bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
11508       bfd_put_16 (output_bfd, gotplt_value_low, loc + 10);
11509       for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++)
11510         bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11511     }
11512   else
11513     {
11514       bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
11515       bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
11516       bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
11517       bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11518       bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11519       bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11520       bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11521       bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11522     }
11523
11524   return TRUE;
11525 }
11526
11527 /* Install the PLT header for a VxWorks executable and finalize the
11528    contents of .rela.plt.unloaded.  */
11529
11530 static void
11531 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11532 {
11533   Elf_Internal_Rela rela;
11534   bfd_byte *loc;
11535   bfd_vma got_value, got_value_high, got_value_low, plt_address;
11536   static const bfd_vma *plt_entry;
11537   struct mips_elf_link_hash_table *htab;
11538
11539   htab = mips_elf_hash_table (info);
11540   BFD_ASSERT (htab != NULL);
11541
11542   plt_entry = mips_vxworks_exec_plt0_entry;
11543
11544   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
11545   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
11546                + htab->root.hgot->root.u.def.section->output_offset
11547                + htab->root.hgot->root.u.def.value);
11548
11549   got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
11550   got_value_low = got_value & 0xffff;
11551
11552   /* Calculate the address of the PLT header.  */
11553   plt_address = (htab->root.splt->output_section->vma
11554                  + htab->root.splt->output_offset);
11555
11556   /* Install the PLT header.  */
11557   loc = htab->root.splt->contents;
11558   bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
11559   bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
11560   bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
11561   bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11562   bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11563   bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11564
11565   /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
11566   loc = htab->srelplt2->contents;
11567   rela.r_offset = plt_address;
11568   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11569   rela.r_addend = 0;
11570   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11571   loc += sizeof (Elf32_External_Rela);
11572
11573   /* Output the relocation for the following addiu of
11574      %lo(_GLOBAL_OFFSET_TABLE_).  */
11575   rela.r_offset += 4;
11576   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11577   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11578   loc += sizeof (Elf32_External_Rela);
11579
11580   /* Fix up the remaining relocations.  They may have the wrong
11581      symbol index for _G_O_T_ or _P_L_T_ depending on the order
11582      in which symbols were output.  */
11583   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
11584     {
11585       Elf_Internal_Rela rel;
11586
11587       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11588       rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11589       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11590       loc += sizeof (Elf32_External_Rela);
11591
11592       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11593       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11594       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11595       loc += sizeof (Elf32_External_Rela);
11596
11597       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11598       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11599       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11600       loc += sizeof (Elf32_External_Rela);
11601     }
11602 }
11603
11604 /* Install the PLT header for a VxWorks shared library.  */
11605
11606 static void
11607 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
11608 {
11609   unsigned int i;
11610   struct mips_elf_link_hash_table *htab;
11611
11612   htab = mips_elf_hash_table (info);
11613   BFD_ASSERT (htab != NULL);
11614
11615   /* We just need to copy the entry byte-by-byte.  */
11616   for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
11617     bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
11618                 htab->root.splt->contents + i * 4);
11619 }
11620
11621 /* Finish up the dynamic sections.  */
11622
11623 bfd_boolean
11624 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
11625                                        struct bfd_link_info *info)
11626 {
11627   bfd *dynobj;
11628   asection *sdyn;
11629   asection *sgot;
11630   struct mips_got_info *gg, *g;
11631   struct mips_elf_link_hash_table *htab;
11632
11633   htab = mips_elf_hash_table (info);
11634   BFD_ASSERT (htab != NULL);
11635
11636   dynobj = elf_hash_table (info)->dynobj;
11637
11638   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
11639
11640   sgot = htab->root.sgot;
11641   gg = htab->got_info;
11642
11643   if (elf_hash_table (info)->dynamic_sections_created)
11644     {
11645       bfd_byte *b;
11646       int dyn_to_skip = 0, dyn_skipped = 0;
11647
11648       BFD_ASSERT (sdyn != NULL);
11649       BFD_ASSERT (gg != NULL);
11650
11651       g = mips_elf_bfd_got (output_bfd, FALSE);
11652       BFD_ASSERT (g != NULL);
11653
11654       for (b = sdyn->contents;
11655            b < sdyn->contents + sdyn->size;
11656            b += MIPS_ELF_DYN_SIZE (dynobj))
11657         {
11658           Elf_Internal_Dyn dyn;
11659           const char *name;
11660           size_t elemsize;
11661           asection *s;
11662           bfd_boolean swap_out_p;
11663
11664           /* Read in the current dynamic entry.  */
11665           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11666
11667           /* Assume that we're going to modify it and write it out.  */
11668           swap_out_p = TRUE;
11669
11670           switch (dyn.d_tag)
11671             {
11672             case DT_RELENT:
11673               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
11674               break;
11675
11676             case DT_RELAENT:
11677               BFD_ASSERT (htab->is_vxworks);
11678               dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
11679               break;
11680
11681             case DT_STRSZ:
11682               /* Rewrite DT_STRSZ.  */
11683               dyn.d_un.d_val =
11684                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
11685               break;
11686
11687             case DT_PLTGOT:
11688               s = htab->root.sgot;
11689               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11690               break;
11691
11692             case DT_MIPS_PLTGOT:
11693               s = htab->root.sgotplt;
11694               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11695               break;
11696
11697             case DT_MIPS_RLD_VERSION:
11698               dyn.d_un.d_val = 1; /* XXX */
11699               break;
11700
11701             case DT_MIPS_FLAGS:
11702               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
11703               break;
11704
11705             case DT_MIPS_TIME_STAMP:
11706               {
11707                 time_t t;
11708                 time (&t);
11709                 dyn.d_un.d_val = t;
11710               }
11711               break;
11712
11713             case DT_MIPS_ICHECKSUM:
11714               /* XXX FIXME: */
11715               swap_out_p = FALSE;
11716               break;
11717
11718             case DT_MIPS_IVERSION:
11719               /* XXX FIXME: */
11720               swap_out_p = FALSE;
11721               break;
11722
11723             case DT_MIPS_BASE_ADDRESS:
11724               s = output_bfd->sections;
11725               BFD_ASSERT (s != NULL);
11726               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
11727               break;
11728
11729             case DT_MIPS_LOCAL_GOTNO:
11730               dyn.d_un.d_val = g->local_gotno;
11731               break;
11732
11733             case DT_MIPS_UNREFEXTNO:
11734               /* The index into the dynamic symbol table which is the
11735                  entry of the first external symbol that is not
11736                  referenced within the same object.  */
11737               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
11738               break;
11739
11740             case DT_MIPS_GOTSYM:
11741               if (htab->global_gotsym)
11742                 {
11743                   dyn.d_un.d_val = htab->global_gotsym->dynindx;
11744                   break;
11745                 }
11746               /* In case if we don't have global got symbols we default
11747                  to setting DT_MIPS_GOTSYM to the same value as
11748                  DT_MIPS_SYMTABNO.  */
11749               /* Fall through.  */
11750
11751             case DT_MIPS_SYMTABNO:
11752               name = ".dynsym";
11753               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
11754               s = bfd_get_linker_section (dynobj, name);
11755
11756               if (s != NULL)
11757                 dyn.d_un.d_val = s->size / elemsize;
11758               else
11759                 dyn.d_un.d_val = 0;
11760               break;
11761
11762             case DT_MIPS_HIPAGENO:
11763               dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
11764               break;
11765
11766             case DT_MIPS_RLD_MAP:
11767               {
11768                 struct elf_link_hash_entry *h;
11769                 h = mips_elf_hash_table (info)->rld_symbol;
11770                 if (!h)
11771                   {
11772                     dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11773                     swap_out_p = FALSE;
11774                     break;
11775                   }
11776                 s = h->root.u.def.section;
11777
11778                 /* The MIPS_RLD_MAP tag stores the absolute address of the
11779                    debug pointer.  */
11780                 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
11781                                   + h->root.u.def.value);
11782               }
11783               break;
11784
11785             case DT_MIPS_RLD_MAP_REL:
11786               {
11787                 struct elf_link_hash_entry *h;
11788                 bfd_vma dt_addr, rld_addr;
11789                 h = mips_elf_hash_table (info)->rld_symbol;
11790                 if (!h)
11791                   {
11792                     dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11793                     swap_out_p = FALSE;
11794                     break;
11795                   }
11796                 s = h->root.u.def.section;
11797
11798                 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11799                    pointer, relative to the address of the tag.  */
11800                 dt_addr = (sdyn->output_section->vma + sdyn->output_offset
11801                            + (b - sdyn->contents));
11802                 rld_addr = (s->output_section->vma + s->output_offset
11803                             + h->root.u.def.value);
11804                 dyn.d_un.d_ptr = rld_addr - dt_addr;
11805               }
11806               break;
11807
11808             case DT_MIPS_OPTIONS:
11809               s = (bfd_get_section_by_name
11810                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
11811               dyn.d_un.d_ptr = s->vma;
11812               break;
11813
11814             case DT_PLTREL:
11815               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11816               if (htab->is_vxworks)
11817                 dyn.d_un.d_val = DT_RELA;
11818               else
11819                 dyn.d_un.d_val = DT_REL;
11820               break;
11821
11822             case DT_PLTRELSZ:
11823               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11824               dyn.d_un.d_val = htab->root.srelplt->size;
11825               break;
11826
11827             case DT_JMPREL:
11828               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11829               dyn.d_un.d_ptr = (htab->root.srelplt->output_section->vma
11830                                 + htab->root.srelplt->output_offset);
11831               break;
11832
11833             case DT_TEXTREL:
11834               /* If we didn't need any text relocations after all, delete
11835                  the dynamic tag.  */
11836               if (!(info->flags & DF_TEXTREL))
11837                 {
11838                   dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11839                   swap_out_p = FALSE;
11840                 }
11841               break;
11842
11843             case DT_FLAGS:
11844               /* If we didn't need any text relocations after all, clear
11845                  DF_TEXTREL from DT_FLAGS.  */
11846               if (!(info->flags & DF_TEXTREL))
11847                 dyn.d_un.d_val &= ~DF_TEXTREL;
11848               else
11849                 swap_out_p = FALSE;
11850               break;
11851
11852             default:
11853               swap_out_p = FALSE;
11854               if (htab->is_vxworks
11855                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
11856                 swap_out_p = TRUE;
11857               break;
11858             }
11859
11860           if (swap_out_p || dyn_skipped)
11861             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11862               (dynobj, &dyn, b - dyn_skipped);
11863
11864           if (dyn_to_skip)
11865             {
11866               dyn_skipped += dyn_to_skip;
11867               dyn_to_skip = 0;
11868             }
11869         }
11870
11871       /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
11872       if (dyn_skipped > 0)
11873         memset (b - dyn_skipped, 0, dyn_skipped);
11874     }
11875
11876   if (sgot != NULL && sgot->size > 0
11877       && !bfd_is_abs_section (sgot->output_section))
11878     {
11879       if (htab->is_vxworks)
11880         {
11881           /* The first entry of the global offset table points to the
11882              ".dynamic" section.  The second is initialized by the
11883              loader and contains the shared library identifier.
11884              The third is also initialized by the loader and points
11885              to the lazy resolution stub.  */
11886           MIPS_ELF_PUT_WORD (output_bfd,
11887                              sdyn->output_offset + sdyn->output_section->vma,
11888                              sgot->contents);
11889           MIPS_ELF_PUT_WORD (output_bfd, 0,
11890                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11891           MIPS_ELF_PUT_WORD (output_bfd, 0,
11892                              sgot->contents
11893                              + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
11894         }
11895       else
11896         {
11897           /* The first entry of the global offset table will be filled at
11898              runtime. The second entry will be used by some runtime loaders.
11899              This isn't the case of IRIX rld.  */
11900           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
11901           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11902                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11903         }
11904
11905       elf_section_data (sgot->output_section)->this_hdr.sh_entsize
11906          = MIPS_ELF_GOT_SIZE (output_bfd);
11907     }
11908
11909   /* Generate dynamic relocations for the non-primary gots.  */
11910   if (gg != NULL && gg->next)
11911     {
11912       Elf_Internal_Rela rel[3];
11913       bfd_vma addend = 0;
11914
11915       memset (rel, 0, sizeof (rel));
11916       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
11917
11918       for (g = gg->next; g->next != gg; g = g->next)
11919         {
11920           bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
11921             + g->next->tls_gotno;
11922
11923           MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
11924                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11925           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11926                              sgot->contents
11927                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11928
11929           if (! bfd_link_pic (info))
11930             continue;
11931
11932           for (; got_index < g->local_gotno; got_index++)
11933             {
11934               if (got_index >= g->assigned_low_gotno
11935                   && got_index <= g->assigned_high_gotno)
11936                 continue;
11937
11938               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
11939                 = got_index * MIPS_ELF_GOT_SIZE (output_bfd);
11940               if (!(mips_elf_create_dynamic_relocation
11941                     (output_bfd, info, rel, NULL,
11942                      bfd_abs_section_ptr,
11943                      0, &addend, sgot)))
11944                 return FALSE;
11945               BFD_ASSERT (addend == 0);
11946             }
11947         }
11948     }
11949
11950   /* The generation of dynamic relocations for the non-primary gots
11951      adds more dynamic relocations.  We cannot count them until
11952      here.  */
11953
11954   if (elf_hash_table (info)->dynamic_sections_created)
11955     {
11956       bfd_byte *b;
11957       bfd_boolean swap_out_p;
11958
11959       BFD_ASSERT (sdyn != NULL);
11960
11961       for (b = sdyn->contents;
11962            b < sdyn->contents + sdyn->size;
11963            b += MIPS_ELF_DYN_SIZE (dynobj))
11964         {
11965           Elf_Internal_Dyn dyn;
11966           asection *s;
11967
11968           /* Read in the current dynamic entry.  */
11969           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11970
11971           /* Assume that we're going to modify it and write it out.  */
11972           swap_out_p = TRUE;
11973
11974           switch (dyn.d_tag)
11975             {
11976             case DT_RELSZ:
11977               /* Reduce DT_RELSZ to account for any relocations we
11978                  decided not to make.  This is for the n64 irix rld,
11979                  which doesn't seem to apply any relocations if there
11980                  are trailing null entries.  */
11981               s = mips_elf_rel_dyn_section (info, FALSE);
11982               dyn.d_un.d_val = (s->reloc_count
11983                                 * (ABI_64_P (output_bfd)
11984                                    ? sizeof (Elf64_Mips_External_Rel)
11985                                    : sizeof (Elf32_External_Rel)));
11986               /* Adjust the section size too.  Tools like the prelinker
11987                  can reasonably expect the values to the same.  */
11988               BFD_ASSERT (!bfd_is_abs_section (s->output_section));
11989               elf_section_data (s->output_section)->this_hdr.sh_size
11990                 = dyn.d_un.d_val;
11991               break;
11992
11993             default:
11994               swap_out_p = FALSE;
11995               break;
11996             }
11997
11998           if (swap_out_p)
11999             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
12000               (dynobj, &dyn, b);
12001         }
12002     }
12003
12004   {
12005     asection *s;
12006     Elf32_compact_rel cpt;
12007
12008     if (SGI_COMPAT (output_bfd))
12009       {
12010         /* Write .compact_rel section out.  */
12011         s = bfd_get_linker_section (dynobj, ".compact_rel");
12012         if (s != NULL)
12013           {
12014             cpt.id1 = 1;
12015             cpt.num = s->reloc_count;
12016             cpt.id2 = 2;
12017             cpt.offset = (s->output_section->filepos
12018                           + sizeof (Elf32_External_compact_rel));
12019             cpt.reserved0 = 0;
12020             cpt.reserved1 = 0;
12021             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
12022                                             ((Elf32_External_compact_rel *)
12023                                              s->contents));
12024
12025             /* Clean up a dummy stub function entry in .text.  */
12026             if (htab->sstubs != NULL)
12027               {
12028                 file_ptr dummy_offset;
12029
12030                 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
12031                 dummy_offset = htab->sstubs->size - htab->function_stub_size;
12032                 memset (htab->sstubs->contents + dummy_offset, 0,
12033                         htab->function_stub_size);
12034               }
12035           }
12036       }
12037
12038     /* The psABI says that the dynamic relocations must be sorted in
12039        increasing order of r_symndx.  The VxWorks EABI doesn't require
12040        this, and because the code below handles REL rather than RELA
12041        relocations, using it for VxWorks would be outright harmful.  */
12042     if (!htab->is_vxworks)
12043       {
12044         s = mips_elf_rel_dyn_section (info, FALSE);
12045         if (s != NULL
12046             && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
12047           {
12048             reldyn_sorting_bfd = output_bfd;
12049
12050             if (ABI_64_P (output_bfd))
12051               qsort ((Elf64_External_Rel *) s->contents + 1,
12052                      s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
12053                      sort_dynamic_relocs_64);
12054             else
12055               qsort ((Elf32_External_Rel *) s->contents + 1,
12056                      s->reloc_count - 1, sizeof (Elf32_External_Rel),
12057                      sort_dynamic_relocs);
12058           }
12059       }
12060   }
12061
12062   if (htab->root.splt && htab->root.splt->size > 0)
12063     {
12064       if (htab->is_vxworks)
12065         {
12066           if (bfd_link_pic (info))
12067             mips_vxworks_finish_shared_plt (output_bfd, info);
12068           else
12069             mips_vxworks_finish_exec_plt (output_bfd, info);
12070         }
12071       else
12072         {
12073           BFD_ASSERT (!bfd_link_pic (info));
12074           if (!mips_finish_exec_plt (output_bfd, info))
12075             return FALSE;
12076         }
12077     }
12078   return TRUE;
12079 }
12080
12081
12082 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
12083
12084 static void
12085 mips_set_isa_flags (bfd *abfd)
12086 {
12087   flagword val;
12088
12089   switch (bfd_get_mach (abfd))
12090     {
12091     default:
12092     case bfd_mach_mips3000:
12093       val = E_MIPS_ARCH_1;
12094       break;
12095
12096     case bfd_mach_mips3900:
12097       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
12098       break;
12099
12100     case bfd_mach_mips6000:
12101       val = E_MIPS_ARCH_2;
12102       break;
12103
12104     case bfd_mach_mips4010:
12105       val = E_MIPS_ARCH_2 | E_MIPS_MACH_4010;
12106       break;
12107
12108     case bfd_mach_mips4000:
12109     case bfd_mach_mips4300:
12110     case bfd_mach_mips4400:
12111     case bfd_mach_mips4600:
12112       val = E_MIPS_ARCH_3;
12113       break;
12114
12115     case bfd_mach_mips4100:
12116       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
12117       break;
12118
12119     case bfd_mach_mips4111:
12120       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
12121       break;
12122
12123     case bfd_mach_mips4120:
12124       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
12125       break;
12126
12127     case bfd_mach_mips4650:
12128       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
12129       break;
12130
12131     case bfd_mach_mips5400:
12132       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
12133       break;
12134
12135     case bfd_mach_mips5500:
12136       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
12137       break;
12138
12139     case bfd_mach_mips5900:
12140       val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
12141       break;
12142
12143     case bfd_mach_mips9000:
12144       val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
12145       break;
12146
12147     case bfd_mach_mips5000:
12148     case bfd_mach_mips7000:
12149     case bfd_mach_mips8000:
12150     case bfd_mach_mips10000:
12151     case bfd_mach_mips12000:
12152     case bfd_mach_mips14000:
12153     case bfd_mach_mips16000:
12154       val = E_MIPS_ARCH_4;
12155       break;
12156
12157     case bfd_mach_mips5:
12158       val = E_MIPS_ARCH_5;
12159       break;
12160
12161     case bfd_mach_mips_loongson_2e:
12162       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
12163       break;
12164
12165     case bfd_mach_mips_loongson_2f:
12166       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
12167       break;
12168
12169     case bfd_mach_mips_sb1:
12170       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
12171       break;
12172
12173     case bfd_mach_mips_gs464:
12174       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS464;
12175       break;
12176
12177     case bfd_mach_mips_gs464e:
12178       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS464E;
12179       break;
12180
12181     case bfd_mach_mips_gs264e:
12182       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS264E;
12183       break;
12184
12185     case bfd_mach_mips_octeon:
12186     case bfd_mach_mips_octeonp:
12187       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
12188       break;
12189
12190     case bfd_mach_mips_octeon3:
12191       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3;
12192       break;
12193
12194     case bfd_mach_mips_xlr:
12195       val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
12196       break;
12197
12198     case bfd_mach_mips_octeon2:
12199       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
12200       break;
12201
12202     case bfd_mach_mipsisa32:
12203       val = E_MIPS_ARCH_32;
12204       break;
12205
12206     case bfd_mach_mipsisa64:
12207       val = E_MIPS_ARCH_64;
12208       break;
12209
12210     case bfd_mach_mipsisa32r2:
12211     case bfd_mach_mipsisa32r3:
12212     case bfd_mach_mipsisa32r5:
12213       val = E_MIPS_ARCH_32R2;
12214       break;
12215
12216     case bfd_mach_mips_interaptiv_mr2:
12217       val = E_MIPS_ARCH_32R2 | E_MIPS_MACH_IAMR2;
12218       break;
12219
12220     case bfd_mach_mipsisa64r2:
12221     case bfd_mach_mipsisa64r3:
12222     case bfd_mach_mipsisa64r5:
12223       val = E_MIPS_ARCH_64R2;
12224       break;
12225
12226     case bfd_mach_mipsisa32r6:
12227       val = E_MIPS_ARCH_32R6;
12228       break;
12229
12230     case bfd_mach_mipsisa64r6:
12231       val = E_MIPS_ARCH_64R6;
12232       break;
12233     }
12234   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
12235   elf_elfheader (abfd)->e_flags |= val;
12236
12237 }
12238
12239
12240 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
12241    Don't do so for code sections.  We want to keep ordering of HI16/LO16
12242    as is.  On the other hand, elf-eh-frame.c processing requires .eh_frame
12243    relocs to be sorted.  */
12244
12245 bfd_boolean
12246 _bfd_mips_elf_sort_relocs_p (asection *sec)
12247 {
12248   return (sec->flags & SEC_CODE) == 0;
12249 }
12250
12251
12252 /* The final processing done just before writing out a MIPS ELF object
12253    file.  This gets the MIPS architecture right based on the machine
12254    number.  This is used by both the 32-bit and the 64-bit ABI.  */
12255
12256 void
12257 _bfd_mips_elf_final_write_processing (bfd *abfd,
12258                                       bfd_boolean linker ATTRIBUTE_UNUSED)
12259 {
12260   unsigned int i;
12261   Elf_Internal_Shdr **hdrpp;
12262   const char *name;
12263   asection *sec;
12264
12265   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
12266      is nonzero.  This is for compatibility with old objects, which used
12267      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
12268   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
12269     mips_set_isa_flags (abfd);
12270
12271   /* Set the sh_info field for .gptab sections and other appropriate
12272      info for each special section.  */
12273   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
12274        i < elf_numsections (abfd);
12275        i++, hdrpp++)
12276     {
12277       switch ((*hdrpp)->sh_type)
12278         {
12279         case SHT_MIPS_MSYM:
12280         case SHT_MIPS_LIBLIST:
12281           sec = bfd_get_section_by_name (abfd, ".dynstr");
12282           if (sec != NULL)
12283             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12284           break;
12285
12286         case SHT_MIPS_GPTAB:
12287           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12288           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12289           BFD_ASSERT (name != NULL
12290                       && CONST_STRNEQ (name, ".gptab."));
12291           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
12292           BFD_ASSERT (sec != NULL);
12293           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12294           break;
12295
12296         case SHT_MIPS_CONTENT:
12297           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12298           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12299           BFD_ASSERT (name != NULL
12300                       && CONST_STRNEQ (name, ".MIPS.content"));
12301           sec = bfd_get_section_by_name (abfd,
12302                                          name + sizeof ".MIPS.content" - 1);
12303           BFD_ASSERT (sec != NULL);
12304           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12305           break;
12306
12307         case SHT_MIPS_SYMBOL_LIB:
12308           sec = bfd_get_section_by_name (abfd, ".dynsym");
12309           if (sec != NULL)
12310             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12311           sec = bfd_get_section_by_name (abfd, ".liblist");
12312           if (sec != NULL)
12313             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12314           break;
12315
12316         case SHT_MIPS_EVENTS:
12317           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12318           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12319           BFD_ASSERT (name != NULL);
12320           if (CONST_STRNEQ (name, ".MIPS.events"))
12321             sec = bfd_get_section_by_name (abfd,
12322                                            name + sizeof ".MIPS.events" - 1);
12323           else
12324             {
12325               BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
12326               sec = bfd_get_section_by_name (abfd,
12327                                              (name
12328                                               + sizeof ".MIPS.post_rel" - 1));
12329             }
12330           BFD_ASSERT (sec != NULL);
12331           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12332           break;
12333
12334         }
12335     }
12336 }
12337 \f
12338 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12339    segments.  */
12340
12341 int
12342 _bfd_mips_elf_additional_program_headers (bfd *abfd,
12343                                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
12344 {
12345   asection *s;
12346   int ret = 0;
12347
12348   /* See if we need a PT_MIPS_REGINFO segment.  */
12349   s = bfd_get_section_by_name (abfd, ".reginfo");
12350   if (s && (s->flags & SEC_LOAD))
12351     ++ret;
12352
12353   /* See if we need a PT_MIPS_ABIFLAGS segment.  */
12354   if (bfd_get_section_by_name (abfd, ".MIPS.abiflags"))
12355     ++ret;
12356
12357   /* See if we need a PT_MIPS_OPTIONS segment.  */
12358   if (IRIX_COMPAT (abfd) == ict_irix6
12359       && bfd_get_section_by_name (abfd,
12360                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
12361     ++ret;
12362
12363   /* See if we need a PT_MIPS_RTPROC segment.  */
12364   if (IRIX_COMPAT (abfd) == ict_irix5
12365       && bfd_get_section_by_name (abfd, ".dynamic")
12366       && bfd_get_section_by_name (abfd, ".mdebug"))
12367     ++ret;
12368
12369   /* Allocate a PT_NULL header in dynamic objects.  See
12370      _bfd_mips_elf_modify_segment_map for details.  */
12371   if (!SGI_COMPAT (abfd)
12372       && bfd_get_section_by_name (abfd, ".dynamic"))
12373     ++ret;
12374
12375   return ret;
12376 }
12377
12378 /* Modify the segment map for an IRIX5 executable.  */
12379
12380 bfd_boolean
12381 _bfd_mips_elf_modify_segment_map (bfd *abfd,
12382                                   struct bfd_link_info *info)
12383 {
12384   asection *s;
12385   struct elf_segment_map *m, **pm;
12386   bfd_size_type amt;
12387
12388   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12389      segment.  */
12390   s = bfd_get_section_by_name (abfd, ".reginfo");
12391   if (s != NULL && (s->flags & SEC_LOAD) != 0)
12392     {
12393       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12394         if (m->p_type == PT_MIPS_REGINFO)
12395           break;
12396       if (m == NULL)
12397         {
12398           amt = sizeof *m;
12399           m = bfd_zalloc (abfd, amt);
12400           if (m == NULL)
12401             return FALSE;
12402
12403           m->p_type = PT_MIPS_REGINFO;
12404           m->count = 1;
12405           m->sections[0] = s;
12406
12407           /* We want to put it after the PHDR and INTERP segments.  */
12408           pm = &elf_seg_map (abfd);
12409           while (*pm != NULL
12410                  && ((*pm)->p_type == PT_PHDR
12411                      || (*pm)->p_type == PT_INTERP))
12412             pm = &(*pm)->next;
12413
12414           m->next = *pm;
12415           *pm = m;
12416         }
12417     }
12418
12419   /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12420      segment.  */
12421   s = bfd_get_section_by_name (abfd, ".MIPS.abiflags");
12422   if (s != NULL && (s->flags & SEC_LOAD) != 0)
12423     {
12424       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12425         if (m->p_type == PT_MIPS_ABIFLAGS)
12426           break;
12427       if (m == NULL)
12428         {
12429           amt = sizeof *m;
12430           m = bfd_zalloc (abfd, amt);
12431           if (m == NULL)
12432             return FALSE;
12433
12434           m->p_type = PT_MIPS_ABIFLAGS;
12435           m->count = 1;
12436           m->sections[0] = s;
12437
12438           /* We want to put it after the PHDR and INTERP segments.  */
12439           pm = &elf_seg_map (abfd);
12440           while (*pm != NULL
12441                  && ((*pm)->p_type == PT_PHDR
12442                      || (*pm)->p_type == PT_INTERP))
12443             pm = &(*pm)->next;
12444
12445           m->next = *pm;
12446           *pm = m;
12447         }
12448     }
12449
12450   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12451      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
12452      PT_MIPS_OPTIONS segment immediately following the program header
12453      table.  */
12454   if (NEWABI_P (abfd)
12455       /* On non-IRIX6 new abi, we'll have already created a segment
12456          for this section, so don't create another.  I'm not sure this
12457          is not also the case for IRIX 6, but I can't test it right
12458          now.  */
12459       && IRIX_COMPAT (abfd) == ict_irix6)
12460     {
12461       for (s = abfd->sections; s; s = s->next)
12462         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
12463           break;
12464
12465       if (s)
12466         {
12467           struct elf_segment_map *options_segment;
12468
12469           pm = &elf_seg_map (abfd);
12470           while (*pm != NULL
12471                  && ((*pm)->p_type == PT_PHDR
12472                      || (*pm)->p_type == PT_INTERP))
12473             pm = &(*pm)->next;
12474
12475           if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
12476             {
12477               amt = sizeof (struct elf_segment_map);
12478               options_segment = bfd_zalloc (abfd, amt);
12479               options_segment->next = *pm;
12480               options_segment->p_type = PT_MIPS_OPTIONS;
12481               options_segment->p_flags = PF_R;
12482               options_segment->p_flags_valid = TRUE;
12483               options_segment->count = 1;
12484               options_segment->sections[0] = s;
12485               *pm = options_segment;
12486             }
12487         }
12488     }
12489   else
12490     {
12491       if (IRIX_COMPAT (abfd) == ict_irix5)
12492         {
12493           /* If there are .dynamic and .mdebug sections, we make a room
12494              for the RTPROC header.  FIXME: Rewrite without section names.  */
12495           if (bfd_get_section_by_name (abfd, ".interp") == NULL
12496               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
12497               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
12498             {
12499               for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12500                 if (m->p_type == PT_MIPS_RTPROC)
12501                   break;
12502               if (m == NULL)
12503                 {
12504                   amt = sizeof *m;
12505                   m = bfd_zalloc (abfd, amt);
12506                   if (m == NULL)
12507                     return FALSE;
12508
12509                   m->p_type = PT_MIPS_RTPROC;
12510
12511                   s = bfd_get_section_by_name (abfd, ".rtproc");
12512                   if (s == NULL)
12513                     {
12514                       m->count = 0;
12515                       m->p_flags = 0;
12516                       m->p_flags_valid = 1;
12517                     }
12518                   else
12519                     {
12520                       m->count = 1;
12521                       m->sections[0] = s;
12522                     }
12523
12524                   /* We want to put it after the DYNAMIC segment.  */
12525                   pm = &elf_seg_map (abfd);
12526                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
12527                     pm = &(*pm)->next;
12528                   if (*pm != NULL)
12529                     pm = &(*pm)->next;
12530
12531                   m->next = *pm;
12532                   *pm = m;
12533                 }
12534             }
12535         }
12536       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12537          .dynstr, .dynsym, and .hash sections, and everything in
12538          between.  */
12539       for (pm = &elf_seg_map (abfd); *pm != NULL;
12540            pm = &(*pm)->next)
12541         if ((*pm)->p_type == PT_DYNAMIC)
12542           break;
12543       m = *pm;
12544       /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12545          glibc's dynamic linker has traditionally derived the number of
12546          tags from the p_filesz field, and sometimes allocates stack
12547          arrays of that size.  An overly-big PT_DYNAMIC segment can
12548          be actively harmful in such cases.  Making PT_DYNAMIC contain
12549          other sections can also make life hard for the prelinker,
12550          which might move one of the other sections to a different
12551          PT_LOAD segment.  */
12552       if (SGI_COMPAT (abfd)
12553           && m != NULL
12554           && m->count == 1
12555           && strcmp (m->sections[0]->name, ".dynamic") == 0)
12556         {
12557           static const char *sec_names[] =
12558           {
12559             ".dynamic", ".dynstr", ".dynsym", ".hash"
12560           };
12561           bfd_vma low, high;
12562           unsigned int i, c;
12563           struct elf_segment_map *n;
12564
12565           low = ~(bfd_vma) 0;
12566           high = 0;
12567           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
12568             {
12569               s = bfd_get_section_by_name (abfd, sec_names[i]);
12570               if (s != NULL && (s->flags & SEC_LOAD) != 0)
12571                 {
12572                   bfd_size_type sz;
12573
12574                   if (low > s->vma)
12575                     low = s->vma;
12576                   sz = s->size;
12577                   if (high < s->vma + sz)
12578                     high = s->vma + sz;
12579                 }
12580             }
12581
12582           c = 0;
12583           for (s = abfd->sections; s != NULL; s = s->next)
12584             if ((s->flags & SEC_LOAD) != 0
12585                 && s->vma >= low
12586                 && s->vma + s->size <= high)
12587               ++c;
12588
12589           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
12590           n = bfd_zalloc (abfd, amt);
12591           if (n == NULL)
12592             return FALSE;
12593           *n = *m;
12594           n->count = c;
12595
12596           i = 0;
12597           for (s = abfd->sections; s != NULL; s = s->next)
12598             {
12599               if ((s->flags & SEC_LOAD) != 0
12600                   && s->vma >= low
12601                   && s->vma + s->size <= high)
12602                 {
12603                   n->sections[i] = s;
12604                   ++i;
12605                 }
12606             }
12607
12608           *pm = n;
12609         }
12610     }
12611
12612   /* Allocate a spare program header in dynamic objects so that tools
12613      like the prelinker can add an extra PT_LOAD entry.
12614
12615      If the prelinker needs to make room for a new PT_LOAD entry, its
12616      standard procedure is to move the first (read-only) sections into
12617      the new (writable) segment.  However, the MIPS ABI requires
12618      .dynamic to be in a read-only segment, and the section will often
12619      start within sizeof (ElfNN_Phdr) bytes of the last program header.
12620
12621      Although the prelinker could in principle move .dynamic to a
12622      writable segment, it seems better to allocate a spare program
12623      header instead, and avoid the need to move any sections.
12624      There is a long tradition of allocating spare dynamic tags,
12625      so allocating a spare program header seems like a natural
12626      extension.
12627
12628      If INFO is NULL, we may be copying an already prelinked binary
12629      with objcopy or strip, so do not add this header.  */
12630   if (info != NULL
12631       && !SGI_COMPAT (abfd)
12632       && bfd_get_section_by_name (abfd, ".dynamic"))
12633     {
12634       for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
12635         if ((*pm)->p_type == PT_NULL)
12636           break;
12637       if (*pm == NULL)
12638         {
12639           m = bfd_zalloc (abfd, sizeof (*m));
12640           if (m == NULL)
12641             return FALSE;
12642
12643           m->p_type = PT_NULL;
12644           *pm = m;
12645         }
12646     }
12647
12648   return TRUE;
12649 }
12650 \f
12651 /* Return the section that should be marked against GC for a given
12652    relocation.  */
12653
12654 asection *
12655 _bfd_mips_elf_gc_mark_hook (asection *sec,
12656                             struct bfd_link_info *info,
12657                             Elf_Internal_Rela *rel,
12658                             struct elf_link_hash_entry *h,
12659                             Elf_Internal_Sym *sym)
12660 {
12661   /* ??? Do mips16 stub sections need to be handled special?  */
12662
12663   if (h != NULL)
12664     switch (ELF_R_TYPE (sec->owner, rel->r_info))
12665       {
12666       case R_MIPS_GNU_VTINHERIT:
12667       case R_MIPS_GNU_VTENTRY:
12668         return NULL;
12669       }
12670
12671   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
12672 }
12673
12674 /* Prevent .MIPS.abiflags from being discarded with --gc-sections.  */
12675
12676 bfd_boolean
12677 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12678                                       elf_gc_mark_hook_fn gc_mark_hook)
12679 {
12680   bfd *sub;
12681
12682   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
12683
12684   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12685     {
12686       asection *o;
12687
12688       if (! is_mips_elf (sub))
12689         continue;
12690
12691       for (o = sub->sections; o != NULL; o = o->next)
12692         if (!o->gc_mark
12693             && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
12694                  (bfd_get_section_name (sub, o)))
12695           {
12696             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12697               return FALSE;
12698           }
12699     }
12700
12701   return TRUE;
12702 }
12703 \f
12704 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12705    hiding the old indirect symbol.  Process additional relocation
12706    information.  Also called for weakdefs, in which case we just let
12707    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
12708
12709 void
12710 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
12711                                     struct elf_link_hash_entry *dir,
12712                                     struct elf_link_hash_entry *ind)
12713 {
12714   struct mips_elf_link_hash_entry *dirmips, *indmips;
12715
12716   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
12717
12718   dirmips = (struct mips_elf_link_hash_entry *) dir;
12719   indmips = (struct mips_elf_link_hash_entry *) ind;
12720   /* Any absolute non-dynamic relocations against an indirect or weak
12721      definition will be against the target symbol.  */
12722   if (indmips->has_static_relocs)
12723     dirmips->has_static_relocs = TRUE;
12724
12725   if (ind->root.type != bfd_link_hash_indirect)
12726     return;
12727
12728   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
12729   if (indmips->readonly_reloc)
12730     dirmips->readonly_reloc = TRUE;
12731   if (indmips->no_fn_stub)
12732     dirmips->no_fn_stub = TRUE;
12733   if (indmips->fn_stub)
12734     {
12735       dirmips->fn_stub = indmips->fn_stub;
12736       indmips->fn_stub = NULL;
12737     }
12738   if (indmips->need_fn_stub)
12739     {
12740       dirmips->need_fn_stub = TRUE;
12741       indmips->need_fn_stub = FALSE;
12742     }
12743   if (indmips->call_stub)
12744     {
12745       dirmips->call_stub = indmips->call_stub;
12746       indmips->call_stub = NULL;
12747     }
12748   if (indmips->call_fp_stub)
12749     {
12750       dirmips->call_fp_stub = indmips->call_fp_stub;
12751       indmips->call_fp_stub = NULL;
12752     }
12753   if (indmips->global_got_area < dirmips->global_got_area)
12754     dirmips->global_got_area = indmips->global_got_area;
12755   if (indmips->global_got_area < GGA_NONE)
12756     indmips->global_got_area = GGA_NONE;
12757   if (indmips->has_nonpic_branches)
12758     dirmips->has_nonpic_branches = TRUE;
12759 }
12760
12761 /* Take care of the special `__gnu_absolute_zero' symbol and ignore attempts
12762    to hide it.  It has to remain global (it will also be protected) so as to
12763    be assigned a global GOT entry, which will then remain unchanged at load
12764    time.  */
12765
12766 void
12767 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
12768                            struct elf_link_hash_entry *entry,
12769                            bfd_boolean force_local)
12770 {
12771   struct mips_elf_link_hash_table *htab;
12772
12773   htab = mips_elf_hash_table (info);
12774   BFD_ASSERT (htab != NULL);
12775   if (htab->use_absolute_zero
12776       && strcmp (entry->root.root.string, "__gnu_absolute_zero") == 0)
12777     return;
12778
12779   _bfd_elf_link_hash_hide_symbol (info, entry, force_local);
12780 }
12781 \f
12782 #define PDR_SIZE 32
12783
12784 bfd_boolean
12785 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
12786                             struct bfd_link_info *info)
12787 {
12788   asection *o;
12789   bfd_boolean ret = FALSE;
12790   unsigned char *tdata;
12791   size_t i, skip;
12792
12793   o = bfd_get_section_by_name (abfd, ".pdr");
12794   if (! o)
12795     return FALSE;
12796   if (o->size == 0)
12797     return FALSE;
12798   if (o->size % PDR_SIZE != 0)
12799     return FALSE;
12800   if (o->output_section != NULL
12801       && bfd_is_abs_section (o->output_section))
12802     return FALSE;
12803
12804   tdata = bfd_zmalloc (o->size / PDR_SIZE);
12805   if (! tdata)
12806     return FALSE;
12807
12808   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
12809                                             info->keep_memory);
12810   if (!cookie->rels)
12811     {
12812       free (tdata);
12813       return FALSE;
12814     }
12815
12816   cookie->rel = cookie->rels;
12817   cookie->relend = cookie->rels + o->reloc_count;
12818
12819   for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
12820     {
12821       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
12822         {
12823           tdata[i] = 1;
12824           skip ++;
12825         }
12826     }
12827
12828   if (skip != 0)
12829     {
12830       mips_elf_section_data (o)->u.tdata = tdata;
12831       if (o->rawsize == 0)
12832         o->rawsize = o->size;
12833       o->size -= skip * PDR_SIZE;
12834       ret = TRUE;
12835     }
12836   else
12837     free (tdata);
12838
12839   if (! info->keep_memory)
12840     free (cookie->rels);
12841
12842   return ret;
12843 }
12844
12845 bfd_boolean
12846 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
12847 {
12848   if (strcmp (sec->name, ".pdr") == 0)
12849     return TRUE;
12850   return FALSE;
12851 }
12852
12853 bfd_boolean
12854 _bfd_mips_elf_write_section (bfd *output_bfd,
12855                              struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
12856                              asection *sec, bfd_byte *contents)
12857 {
12858   bfd_byte *to, *from, *end;
12859   int i;
12860
12861   if (strcmp (sec->name, ".pdr") != 0)
12862     return FALSE;
12863
12864   if (mips_elf_section_data (sec)->u.tdata == NULL)
12865     return FALSE;
12866
12867   to = contents;
12868   end = contents + sec->size;
12869   for (from = contents, i = 0;
12870        from < end;
12871        from += PDR_SIZE, i++)
12872     {
12873       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
12874         continue;
12875       if (to != from)
12876         memcpy (to, from, PDR_SIZE);
12877       to += PDR_SIZE;
12878     }
12879   bfd_set_section_contents (output_bfd, sec->output_section, contents,
12880                             sec->output_offset, sec->size);
12881   return TRUE;
12882 }
12883 \f
12884 /* microMIPS code retains local labels for linker relaxation.  Omit them
12885    from output by default for clarity.  */
12886
12887 bfd_boolean
12888 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
12889 {
12890   return _bfd_elf_is_local_label_name (abfd, sym->name);
12891 }
12892
12893 /* MIPS ELF uses a special find_nearest_line routine in order the
12894    handle the ECOFF debugging information.  */
12895
12896 struct mips_elf_find_line
12897 {
12898   struct ecoff_debug_info d;
12899   struct ecoff_find_line i;
12900 };
12901
12902 bfd_boolean
12903 _bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols,
12904                                  asection *section, bfd_vma offset,
12905                                  const char **filename_ptr,
12906                                  const char **functionname_ptr,
12907                                  unsigned int *line_ptr,
12908                                  unsigned int *discriminator_ptr)
12909 {
12910   asection *msec;
12911
12912   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
12913                                      filename_ptr, functionname_ptr,
12914                                      line_ptr, discriminator_ptr,
12915                                      dwarf_debug_sections,
12916                                      ABI_64_P (abfd) ? 8 : 0,
12917                                      &elf_tdata (abfd)->dwarf2_find_line_info)
12918       || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
12919                                         filename_ptr, functionname_ptr,
12920                                         line_ptr))
12921     {
12922       /* PR 22789: If the function name or filename was not found through
12923          the debug information, then try an ordinary lookup instead.  */
12924       if ((functionname_ptr != NULL && *functionname_ptr == NULL)
12925           || (filename_ptr != NULL && *filename_ptr == NULL))
12926         {
12927           /* Do not override already discovered names.  */
12928           if (functionname_ptr != NULL && *functionname_ptr != NULL)
12929             functionname_ptr = NULL;
12930
12931           if (filename_ptr != NULL && *filename_ptr != NULL)
12932             filename_ptr = NULL;
12933
12934           _bfd_elf_find_function (abfd, symbols, section, offset,
12935                                   filename_ptr, functionname_ptr);
12936         }
12937
12938       return TRUE;
12939     }
12940
12941   msec = bfd_get_section_by_name (abfd, ".mdebug");
12942   if (msec != NULL)
12943     {
12944       flagword origflags;
12945       struct mips_elf_find_line *fi;
12946       const struct ecoff_debug_swap * const swap =
12947         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
12948
12949       /* If we are called during a link, mips_elf_final_link may have
12950          cleared the SEC_HAS_CONTENTS field.  We force it back on here
12951          if appropriate (which it normally will be).  */
12952       origflags = msec->flags;
12953       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
12954         msec->flags |= SEC_HAS_CONTENTS;
12955
12956       fi = mips_elf_tdata (abfd)->find_line_info;
12957       if (fi == NULL)
12958         {
12959           bfd_size_type external_fdr_size;
12960           char *fraw_src;
12961           char *fraw_end;
12962           struct fdr *fdr_ptr;
12963           bfd_size_type amt = sizeof (struct mips_elf_find_line);
12964
12965           fi = bfd_zalloc (abfd, amt);
12966           if (fi == NULL)
12967             {
12968               msec->flags = origflags;
12969               return FALSE;
12970             }
12971
12972           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
12973             {
12974               msec->flags = origflags;
12975               return FALSE;
12976             }
12977
12978           /* Swap in the FDR information.  */
12979           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
12980           fi->d.fdr = bfd_alloc (abfd, amt);
12981           if (fi->d.fdr == NULL)
12982             {
12983               msec->flags = origflags;
12984               return FALSE;
12985             }
12986           external_fdr_size = swap->external_fdr_size;
12987           fdr_ptr = fi->d.fdr;
12988           fraw_src = (char *) fi->d.external_fdr;
12989           fraw_end = (fraw_src
12990                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
12991           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
12992             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
12993
12994           mips_elf_tdata (abfd)->find_line_info = fi;
12995
12996           /* Note that we don't bother to ever free this information.
12997              find_nearest_line is either called all the time, as in
12998              objdump -l, so the information should be saved, or it is
12999              rarely called, as in ld error messages, so the memory
13000              wasted is unimportant.  Still, it would probably be a
13001              good idea for free_cached_info to throw it away.  */
13002         }
13003
13004       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
13005                                   &fi->i, filename_ptr, functionname_ptr,
13006                                   line_ptr))
13007         {
13008           msec->flags = origflags;
13009           return TRUE;
13010         }
13011
13012       msec->flags = origflags;
13013     }
13014
13015   /* Fall back on the generic ELF find_nearest_line routine.  */
13016
13017   return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
13018                                      filename_ptr, functionname_ptr,
13019                                      line_ptr, discriminator_ptr);
13020 }
13021
13022 bfd_boolean
13023 _bfd_mips_elf_find_inliner_info (bfd *abfd,
13024                                  const char **filename_ptr,
13025                                  const char **functionname_ptr,
13026                                  unsigned int *line_ptr)
13027 {
13028   bfd_boolean found;
13029   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
13030                                          functionname_ptr, line_ptr,
13031                                          & elf_tdata (abfd)->dwarf2_find_line_info);
13032   return found;
13033 }
13034
13035 \f
13036 /* When are writing out the .options or .MIPS.options section,
13037    remember the bytes we are writing out, so that we can install the
13038    GP value in the section_processing routine.  */
13039
13040 bfd_boolean
13041 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
13042                                     const void *location,
13043                                     file_ptr offset, bfd_size_type count)
13044 {
13045   if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
13046     {
13047       bfd_byte *c;
13048
13049       if (elf_section_data (section) == NULL)
13050         {
13051           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
13052           section->used_by_bfd = bfd_zalloc (abfd, amt);
13053           if (elf_section_data (section) == NULL)
13054             return FALSE;
13055         }
13056       c = mips_elf_section_data (section)->u.tdata;
13057       if (c == NULL)
13058         {
13059           c = bfd_zalloc (abfd, section->size);
13060           if (c == NULL)
13061             return FALSE;
13062           mips_elf_section_data (section)->u.tdata = c;
13063         }
13064
13065       memcpy (c + offset, location, count);
13066     }
13067
13068   return _bfd_elf_set_section_contents (abfd, section, location, offset,
13069                                         count);
13070 }
13071
13072 /* This is almost identical to bfd_generic_get_... except that some
13073    MIPS relocations need to be handled specially.  Sigh.  */
13074
13075 bfd_byte *
13076 _bfd_elf_mips_get_relocated_section_contents
13077   (bfd *abfd,
13078    struct bfd_link_info *link_info,
13079    struct bfd_link_order *link_order,
13080    bfd_byte *data,
13081    bfd_boolean relocatable,
13082    asymbol **symbols)
13083 {
13084   /* Get enough memory to hold the stuff */
13085   bfd *input_bfd = link_order->u.indirect.section->owner;
13086   asection *input_section = link_order->u.indirect.section;
13087   bfd_size_type sz;
13088
13089   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13090   arelent **reloc_vector = NULL;
13091   long reloc_count;
13092
13093   if (reloc_size < 0)
13094     goto error_return;
13095
13096   reloc_vector = bfd_malloc (reloc_size);
13097   if (reloc_vector == NULL && reloc_size != 0)
13098     goto error_return;
13099
13100   /* read in the section */
13101   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
13102   if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
13103     goto error_return;
13104
13105   reloc_count = bfd_canonicalize_reloc (input_bfd,
13106                                         input_section,
13107                                         reloc_vector,
13108                                         symbols);
13109   if (reloc_count < 0)
13110     goto error_return;
13111
13112   if (reloc_count > 0)
13113     {
13114       arelent **parent;
13115       /* for mips */
13116       int gp_found;
13117       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
13118
13119       {
13120         struct bfd_hash_entry *h;
13121         struct bfd_link_hash_entry *lh;
13122         /* Skip all this stuff if we aren't mixing formats.  */
13123         if (abfd && input_bfd
13124             && abfd->xvec == input_bfd->xvec)
13125           lh = 0;
13126         else
13127           {
13128             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
13129             lh = (struct bfd_link_hash_entry *) h;
13130           }
13131       lookup:
13132         if (lh)
13133           {
13134             switch (lh->type)
13135               {
13136               case bfd_link_hash_undefined:
13137               case bfd_link_hash_undefweak:
13138               case bfd_link_hash_common:
13139                 gp_found = 0;
13140                 break;
13141               case bfd_link_hash_defined:
13142               case bfd_link_hash_defweak:
13143                 gp_found = 1;
13144                 gp = lh->u.def.value;
13145                 break;
13146               case bfd_link_hash_indirect:
13147               case bfd_link_hash_warning:
13148                 lh = lh->u.i.link;
13149                 /* @@FIXME  ignoring warning for now */
13150                 goto lookup;
13151               case bfd_link_hash_new:
13152               default:
13153                 abort ();
13154               }
13155           }
13156         else
13157           gp_found = 0;
13158       }
13159       /* end mips */
13160       for (parent = reloc_vector; *parent != NULL; parent++)
13161         {
13162           char *error_message = NULL;
13163           bfd_reloc_status_type r;
13164
13165           /* Specific to MIPS: Deal with relocation types that require
13166              knowing the gp of the output bfd.  */
13167           asymbol *sym = *(*parent)->sym_ptr_ptr;
13168
13169           /* If we've managed to find the gp and have a special
13170              function for the relocation then go ahead, else default
13171              to the generic handling.  */
13172           if (gp_found
13173               && (*parent)->howto->special_function
13174               == _bfd_mips_elf32_gprel16_reloc)
13175             r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
13176                                                input_section, relocatable,
13177                                                data, gp);
13178           else
13179             r = bfd_perform_relocation (input_bfd, *parent, data,
13180                                         input_section,
13181                                         relocatable ? abfd : NULL,
13182                                         &error_message);
13183
13184           if (relocatable)
13185             {
13186               asection *os = input_section->output_section;
13187
13188               /* A partial link, so keep the relocs */
13189               os->orelocation[os->reloc_count] = *parent;
13190               os->reloc_count++;
13191             }
13192
13193           if (r != bfd_reloc_ok)
13194             {
13195               switch (r)
13196                 {
13197                 case bfd_reloc_undefined:
13198                   (*link_info->callbacks->undefined_symbol)
13199                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13200                      input_bfd, input_section, (*parent)->address, TRUE);
13201                   break;
13202                 case bfd_reloc_dangerous:
13203                   BFD_ASSERT (error_message != NULL);
13204                   (*link_info->callbacks->reloc_dangerous)
13205                     (link_info, error_message,
13206                      input_bfd, input_section, (*parent)->address);
13207                   break;
13208                 case bfd_reloc_overflow:
13209                   (*link_info->callbacks->reloc_overflow)
13210                     (link_info, NULL,
13211                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13212                      (*parent)->howto->name, (*parent)->addend,
13213                      input_bfd, input_section, (*parent)->address);
13214                   break;
13215                 case bfd_reloc_outofrange:
13216                 default:
13217                   abort ();
13218                   break;
13219                 }
13220
13221             }
13222         }
13223     }
13224   if (reloc_vector != NULL)
13225     free (reloc_vector);
13226   return data;
13227
13228 error_return:
13229   if (reloc_vector != NULL)
13230     free (reloc_vector);
13231   return NULL;
13232 }
13233 \f
13234 static bfd_boolean
13235 mips_elf_relax_delete_bytes (bfd *abfd,
13236                              asection *sec, bfd_vma addr, int count)
13237 {
13238   Elf_Internal_Shdr *symtab_hdr;
13239   unsigned int sec_shndx;
13240   bfd_byte *contents;
13241   Elf_Internal_Rela *irel, *irelend;
13242   Elf_Internal_Sym *isym;
13243   Elf_Internal_Sym *isymend;
13244   struct elf_link_hash_entry **sym_hashes;
13245   struct elf_link_hash_entry **end_hashes;
13246   struct elf_link_hash_entry **start_hashes;
13247   unsigned int symcount;
13248
13249   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
13250   contents = elf_section_data (sec)->this_hdr.contents;
13251
13252   irel = elf_section_data (sec)->relocs;
13253   irelend = irel + sec->reloc_count;
13254
13255   /* Actually delete the bytes.  */
13256   memmove (contents + addr, contents + addr + count,
13257            (size_t) (sec->size - addr - count));
13258   sec->size -= count;
13259
13260   /* Adjust all the relocs.  */
13261   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
13262     {
13263       /* Get the new reloc address.  */
13264       if (irel->r_offset > addr)
13265         irel->r_offset -= count;
13266     }
13267
13268   BFD_ASSERT (addr % 2 == 0);
13269   BFD_ASSERT (count % 2 == 0);
13270
13271   /* Adjust the local symbols defined in this section.  */
13272   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13273   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
13274   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
13275     if (isym->st_shndx == sec_shndx && isym->st_value > addr)
13276       isym->st_value -= count;
13277
13278   /* Now adjust the global symbols defined in this section.  */
13279   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
13280               - symtab_hdr->sh_info);
13281   sym_hashes = start_hashes = elf_sym_hashes (abfd);
13282   end_hashes = sym_hashes + symcount;
13283
13284   for (; sym_hashes < end_hashes; sym_hashes++)
13285     {
13286       struct elf_link_hash_entry *sym_hash = *sym_hashes;
13287
13288       if ((sym_hash->root.type == bfd_link_hash_defined
13289            || sym_hash->root.type == bfd_link_hash_defweak)
13290           && sym_hash->root.u.def.section == sec)
13291         {
13292           bfd_vma value = sym_hash->root.u.def.value;
13293
13294           if (ELF_ST_IS_MICROMIPS (sym_hash->other))
13295             value &= MINUS_TWO;
13296           if (value > addr)
13297             sym_hash->root.u.def.value -= count;
13298         }
13299     }
13300
13301   return TRUE;
13302 }
13303
13304
13305 /* Opcodes needed for microMIPS relaxation as found in
13306    opcodes/micromips-opc.c.  */
13307
13308 struct opcode_descriptor {
13309   unsigned long match;
13310   unsigned long mask;
13311 };
13312
13313 /* The $ra register aka $31.  */
13314
13315 #define RA 31
13316
13317 /* 32-bit instruction format register fields.  */
13318
13319 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13320 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13321
13322 /* Check if a 5-bit register index can be abbreviated to 3 bits.  */
13323
13324 #define OP16_VALID_REG(r) \
13325   ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13326
13327
13328 /* 32-bit and 16-bit branches.  */
13329
13330 static const struct opcode_descriptor b_insns_32[] = {
13331   { /* "b",     "p",            */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13332   { /* "b",     "p",            */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13333   { 0, 0 }  /* End marker for find_match().  */
13334 };
13335
13336 static const struct opcode_descriptor bc_insn_32 =
13337   { /* "bc(1|2)(ft)", "N,p",    */ 0x42800000, 0xfec30000 };
13338
13339 static const struct opcode_descriptor bz_insn_32 =
13340   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 };
13341
13342 static const struct opcode_descriptor bzal_insn_32 =
13343   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 };
13344
13345 static const struct opcode_descriptor beq_insn_32 =
13346   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 };
13347
13348 static const struct opcode_descriptor b_insn_16 =
13349   { /* "b",     "mD",           */ 0xcc00,     0xfc00 };
13350
13351 static const struct opcode_descriptor bz_insn_16 =
13352   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 };
13353
13354
13355 /* 32-bit and 16-bit branch EQ and NE zero.  */
13356
13357 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13358    eq and second the ne.  This convention is used when replacing a
13359    32-bit BEQ/BNE with the 16-bit version.  */
13360
13361 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13362
13363 static const struct opcode_descriptor bz_rs_insns_32[] = {
13364   { /* "beqz",  "s,p",          */ 0x94000000, 0xffe00000 },
13365   { /* "bnez",  "s,p",          */ 0xb4000000, 0xffe00000 },
13366   { 0, 0 }  /* End marker for find_match().  */
13367 };
13368
13369 static const struct opcode_descriptor bz_rt_insns_32[] = {
13370   { /* "beqz",  "t,p",          */ 0x94000000, 0xfc01f000 },
13371   { /* "bnez",  "t,p",          */ 0xb4000000, 0xfc01f000 },
13372   { 0, 0 }  /* End marker for find_match().  */
13373 };
13374
13375 static const struct opcode_descriptor bzc_insns_32[] = {
13376   { /* "beqzc", "s,p",          */ 0x40e00000, 0xffe00000 },
13377   { /* "bnezc", "s,p",          */ 0x40a00000, 0xffe00000 },
13378   { 0, 0 }  /* End marker for find_match().  */
13379 };
13380
13381 static const struct opcode_descriptor bz_insns_16[] = {
13382   { /* "beqz",  "md,mE",        */ 0x8c00,     0xfc00 },
13383   { /* "bnez",  "md,mE",        */ 0xac00,     0xfc00 },
13384   { 0, 0 }  /* End marker for find_match().  */
13385 };
13386
13387 /* Switch between a 5-bit register index and its 3-bit shorthand.  */
13388
13389 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2)
13390 #define BZ16_REG_FIELD(r) (((r) & 7) << 7)
13391
13392
13393 /* 32-bit instructions with a delay slot.  */
13394
13395 static const struct opcode_descriptor jal_insn_32_bd16 =
13396   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 };
13397
13398 static const struct opcode_descriptor jal_insn_32_bd32 =
13399   { /* "jal",   "a",            */ 0xf4000000, 0xfc000000 };
13400
13401 static const struct opcode_descriptor jal_x_insn_32_bd32 =
13402   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 };
13403
13404 static const struct opcode_descriptor j_insn_32 =
13405   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 };
13406
13407 static const struct opcode_descriptor jalr_insn_32 =
13408   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff };
13409
13410 /* This table can be compacted, because no opcode replacement is made.  */
13411
13412 static const struct opcode_descriptor ds_insns_32_bd16[] = {
13413   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 },
13414
13415   { /* "jalrs[.hb]", "t,s",     */ 0x00004f3c, 0xfc00efff },
13416   { /* "b(ge|lt)zals", "s,p",   */ 0x42200000, 0xffa00000 },
13417
13418   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 },
13419   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 },
13420   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 },
13421   { 0, 0 }  /* End marker for find_match().  */
13422 };
13423
13424 /* This table can be compacted, because no opcode replacement is made.  */
13425
13426 static const struct opcode_descriptor ds_insns_32_bd32[] = {
13427   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 },
13428
13429   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff },
13430   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 },
13431   { 0, 0 }  /* End marker for find_match().  */
13432 };
13433
13434
13435 /* 16-bit instructions with a delay slot.  */
13436
13437 static const struct opcode_descriptor jalr_insn_16_bd16 =
13438   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 };
13439
13440 static const struct opcode_descriptor jalr_insn_16_bd32 =
13441   { /* "jalr",  "my,mj",        */ 0x45c0,     0xffe0 };
13442
13443 static const struct opcode_descriptor jr_insn_16 =
13444   { /* "jr",    "mj",           */ 0x4580,     0xffe0 };
13445
13446 #define JR16_REG(opcode) ((opcode) & 0x1f)
13447
13448 /* This table can be compacted, because no opcode replacement is made.  */
13449
13450 static const struct opcode_descriptor ds_insns_16_bd16[] = {
13451   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 },
13452
13453   { /* "b",     "mD",           */ 0xcc00,     0xfc00 },
13454   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 },
13455   { /* "jr",    "mj",           */ 0x4580,     0xffe0 },
13456   { 0, 0 }  /* End marker for find_match().  */
13457 };
13458
13459
13460 /* LUI instruction.  */
13461
13462 static const struct opcode_descriptor lui_insn =
13463  { /* "lui",    "s,u",          */ 0x41a00000, 0xffe00000 };
13464
13465
13466 /* ADDIU instruction.  */
13467
13468 static const struct opcode_descriptor addiu_insn =
13469   { /* "addiu", "t,r,j",        */ 0x30000000, 0xfc000000 };
13470
13471 static const struct opcode_descriptor addiupc_insn =
13472   { /* "addiu", "mb,$pc,mQ",    */ 0x78000000, 0xfc000000 };
13473
13474 #define ADDIUPC_REG_FIELD(r) \
13475   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13476
13477
13478 /* Relaxable instructions in a JAL delay slot: MOVE.  */
13479
13480 /* The 16-bit move has rd in 9:5 and rs in 4:0.  The 32-bit moves
13481    (ADDU, OR) have rd in 15:11 and rs in 10:16.  */
13482 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13483 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13484
13485 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13486 #define MOVE16_RS_FIELD(r) (((r) & 0x1f)     )
13487
13488 static const struct opcode_descriptor move_insns_32[] = {
13489   { /* "move",  "d,s",          */ 0x00000290, 0xffe007ff }, /* or   d,s,$0 */
13490   { /* "move",  "d,s",          */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13491   { 0, 0 }  /* End marker for find_match().  */
13492 };
13493
13494 static const struct opcode_descriptor move_insn_16 =
13495   { /* "move",  "mp,mj",        */ 0x0c00,     0xfc00 };
13496
13497
13498 /* NOP instructions.  */
13499
13500 static const struct opcode_descriptor nop_insn_32 =
13501   { /* "nop",   "",             */ 0x00000000, 0xffffffff };
13502
13503 static const struct opcode_descriptor nop_insn_16 =
13504   { /* "nop",   "",             */ 0x0c00,     0xffff };
13505
13506
13507 /* Instruction match support.  */
13508
13509 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13510
13511 static int
13512 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
13513 {
13514   unsigned long indx;
13515
13516   for (indx = 0; insn[indx].mask != 0; indx++)
13517     if (MATCH (opcode, insn[indx]))
13518       return indx;
13519
13520   return -1;
13521 }
13522
13523
13524 /* Branch and delay slot decoding support.  */
13525
13526 /* If PTR points to what *might* be a 16-bit branch or jump, then
13527    return the minimum length of its delay slot, otherwise return 0.
13528    Non-zero results are not definitive as we might be checking against
13529    the second half of another instruction.  */
13530
13531 static int
13532 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
13533 {
13534   unsigned long opcode;
13535   int bdsize;
13536
13537   opcode = bfd_get_16 (abfd, ptr);
13538   if (MATCH (opcode, jalr_insn_16_bd32) != 0)
13539     /* 16-bit branch/jump with a 32-bit delay slot.  */
13540     bdsize = 4;
13541   else if (MATCH (opcode, jalr_insn_16_bd16) != 0
13542            || find_match (opcode, ds_insns_16_bd16) >= 0)
13543     /* 16-bit branch/jump with a 16-bit delay slot.  */
13544     bdsize = 2;
13545   else
13546     /* No delay slot.  */
13547     bdsize = 0;
13548
13549   return bdsize;
13550 }
13551
13552 /* If PTR points to what *might* be a 32-bit branch or jump, then
13553    return the minimum length of its delay slot, otherwise return 0.
13554    Non-zero results are not definitive as we might be checking against
13555    the second half of another instruction.  */
13556
13557 static int
13558 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
13559 {
13560   unsigned long opcode;
13561   int bdsize;
13562
13563   opcode = bfd_get_micromips_32 (abfd, ptr);
13564   if (find_match (opcode, ds_insns_32_bd32) >= 0)
13565     /* 32-bit branch/jump with a 32-bit delay slot.  */
13566     bdsize = 4;
13567   else if (find_match (opcode, ds_insns_32_bd16) >= 0)
13568     /* 32-bit branch/jump with a 16-bit delay slot.  */
13569     bdsize = 2;
13570   else
13571     /* No delay slot.  */
13572     bdsize = 0;
13573
13574   return bdsize;
13575 }
13576
13577 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13578    that doesn't fiddle with REG, then return TRUE, otherwise FALSE.  */
13579
13580 static bfd_boolean
13581 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13582 {
13583   unsigned long opcode;
13584
13585   opcode = bfd_get_16 (abfd, ptr);
13586   if (MATCH (opcode, b_insn_16)
13587                                                 /* B16  */
13588       || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
13589                                                 /* JR16  */
13590       || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
13591                                                 /* BEQZ16, BNEZ16  */
13592       || (MATCH (opcode, jalr_insn_16_bd32)
13593                                                 /* JALR16  */
13594           && reg != JR16_REG (opcode) && reg != RA))
13595     return TRUE;
13596
13597   return FALSE;
13598 }
13599
13600 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13601    then return TRUE, otherwise FALSE.  */
13602
13603 static bfd_boolean
13604 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13605 {
13606   unsigned long opcode;
13607
13608   opcode = bfd_get_micromips_32 (abfd, ptr);
13609   if (MATCH (opcode, j_insn_32)
13610                                                 /* J  */
13611       || MATCH (opcode, bc_insn_32)
13612                                                 /* BC1F, BC1T, BC2F, BC2T  */
13613       || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
13614                                                 /* JAL, JALX  */
13615       || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
13616                                                 /* BGEZ, BGTZ, BLEZ, BLTZ  */
13617       || (MATCH (opcode, bzal_insn_32)
13618                                                 /* BGEZAL, BLTZAL  */
13619           && reg != OP32_SREG (opcode) && reg != RA)
13620       || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
13621                                                 /* JALR, JALR.HB, BEQ, BNE  */
13622           && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
13623     return TRUE;
13624
13625   return FALSE;
13626 }
13627
13628 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13629    IRELEND) at OFFSET indicate that there must be a compact branch there,
13630    then return TRUE, otherwise FALSE.  */
13631
13632 static bfd_boolean
13633 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
13634                      const Elf_Internal_Rela *internal_relocs,
13635                      const Elf_Internal_Rela *irelend)
13636 {
13637   const Elf_Internal_Rela *irel;
13638   unsigned long opcode;
13639
13640   opcode = bfd_get_micromips_32 (abfd, ptr);
13641   if (find_match (opcode, bzc_insns_32) < 0)
13642     return FALSE;
13643
13644   for (irel = internal_relocs; irel < irelend; irel++)
13645     if (irel->r_offset == offset
13646         && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
13647       return TRUE;
13648
13649   return FALSE;
13650 }
13651
13652 /* Bitsize checking.  */
13653 #define IS_BITSIZE(val, N)                                              \
13654   (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1)))               \
13655     - (1ULL << ((N) - 1))) == (val))
13656
13657 \f
13658 bfd_boolean
13659 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
13660                              struct bfd_link_info *link_info,
13661                              bfd_boolean *again)
13662 {
13663   bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32;
13664   Elf_Internal_Shdr *symtab_hdr;
13665   Elf_Internal_Rela *internal_relocs;
13666   Elf_Internal_Rela *irel, *irelend;
13667   bfd_byte *contents = NULL;
13668   Elf_Internal_Sym *isymbuf = NULL;
13669
13670   /* Assume nothing changes.  */
13671   *again = FALSE;
13672
13673   /* We don't have to do anything for a relocatable link, if
13674      this section does not have relocs, or if this is not a
13675      code section.  */
13676
13677   if (bfd_link_relocatable (link_info)
13678       || (sec->flags & SEC_RELOC) == 0
13679       || sec->reloc_count == 0
13680       || (sec->flags & SEC_CODE) == 0)
13681     return TRUE;
13682
13683   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13684
13685   /* Get a copy of the native relocations.  */
13686   internal_relocs = (_bfd_elf_link_read_relocs
13687                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
13688                       link_info->keep_memory));
13689   if (internal_relocs == NULL)
13690     goto error_return;
13691
13692   /* Walk through them looking for relaxing opportunities.  */
13693   irelend = internal_relocs + sec->reloc_count;
13694   for (irel = internal_relocs; irel < irelend; irel++)
13695     {
13696       unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
13697       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
13698       bfd_boolean target_is_micromips_code_p;
13699       unsigned long opcode;
13700       bfd_vma symval;
13701       bfd_vma pcrval;
13702       bfd_byte *ptr;
13703       int fndopc;
13704
13705       /* The number of bytes to delete for relaxation and from where
13706          to delete these bytes starting at irel->r_offset.  */
13707       int delcnt = 0;
13708       int deloff = 0;
13709
13710       /* If this isn't something that can be relaxed, then ignore
13711          this reloc.  */
13712       if (r_type != R_MICROMIPS_HI16
13713           && r_type != R_MICROMIPS_PC16_S1
13714           && r_type != R_MICROMIPS_26_S1)
13715         continue;
13716
13717       /* Get the section contents if we haven't done so already.  */
13718       if (contents == NULL)
13719         {
13720           /* Get cached copy if it exists.  */
13721           if (elf_section_data (sec)->this_hdr.contents != NULL)
13722             contents = elf_section_data (sec)->this_hdr.contents;
13723           /* Go get them off disk.  */
13724           else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
13725             goto error_return;
13726         }
13727       ptr = contents + irel->r_offset;
13728
13729       /* Read this BFD's local symbols if we haven't done so already.  */
13730       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
13731         {
13732           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
13733           if (isymbuf == NULL)
13734             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
13735                                             symtab_hdr->sh_info, 0,
13736                                             NULL, NULL, NULL);
13737           if (isymbuf == NULL)
13738             goto error_return;
13739         }
13740
13741       /* Get the value of the symbol referred to by the reloc.  */
13742       if (r_symndx < symtab_hdr->sh_info)
13743         {
13744           /* A local symbol.  */
13745           Elf_Internal_Sym *isym;
13746           asection *sym_sec;
13747
13748           isym = isymbuf + r_symndx;
13749           if (isym->st_shndx == SHN_UNDEF)
13750             sym_sec = bfd_und_section_ptr;
13751           else if (isym->st_shndx == SHN_ABS)
13752             sym_sec = bfd_abs_section_ptr;
13753           else if (isym->st_shndx == SHN_COMMON)
13754             sym_sec = bfd_com_section_ptr;
13755           else
13756             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
13757           symval = (isym->st_value
13758                     + sym_sec->output_section->vma
13759                     + sym_sec->output_offset);
13760           target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
13761         }
13762       else
13763         {
13764           unsigned long indx;
13765           struct elf_link_hash_entry *h;
13766
13767           /* An external symbol.  */
13768           indx = r_symndx - symtab_hdr->sh_info;
13769           h = elf_sym_hashes (abfd)[indx];
13770           BFD_ASSERT (h != NULL);
13771
13772           if (h->root.type != bfd_link_hash_defined
13773               && h->root.type != bfd_link_hash_defweak)
13774             /* This appears to be a reference to an undefined
13775                symbol.  Just ignore it -- it will be caught by the
13776                regular reloc processing.  */
13777             continue;
13778
13779           symval = (h->root.u.def.value
13780                     + h->root.u.def.section->output_section->vma
13781                     + h->root.u.def.section->output_offset);
13782           target_is_micromips_code_p = (!h->needs_plt
13783                                         && ELF_ST_IS_MICROMIPS (h->other));
13784         }
13785
13786
13787       /* For simplicity of coding, we are going to modify the
13788          section contents, the section relocs, and the BFD symbol
13789          table.  We must tell the rest of the code not to free up this
13790          information.  It would be possible to instead create a table
13791          of changes which have to be made, as is done in coff-mips.c;
13792          that would be more work, but would require less memory when
13793          the linker is run.  */
13794
13795       /* Only 32-bit instructions relaxed.  */
13796       if (irel->r_offset + 4 > sec->size)
13797         continue;
13798
13799       opcode = bfd_get_micromips_32 (abfd, ptr);
13800
13801       /* This is the pc-relative distance from the instruction the
13802          relocation is applied to, to the symbol referred.  */
13803       pcrval = (symval
13804                 - (sec->output_section->vma + sec->output_offset)
13805                 - irel->r_offset);
13806
13807       /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13808          of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13809          R_MICROMIPS_PC23_S2.  The R_MICROMIPS_PC23_S2 condition is
13810
13811            (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13812
13813          where pcrval has first to be adjusted to apply against the LO16
13814          location (we make the adjustment later on, when we have figured
13815          out the offset).  */
13816       if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
13817         {
13818           bfd_boolean bzc = FALSE;
13819           unsigned long nextopc;
13820           unsigned long reg;
13821           bfd_vma offset;
13822
13823           /* Give up if the previous reloc was a HI16 against this symbol
13824              too.  */
13825           if (irel > internal_relocs
13826               && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
13827               && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
13828             continue;
13829
13830           /* Or if the next reloc is not a LO16 against this symbol.  */
13831           if (irel + 1 >= irelend
13832               || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
13833               || ELF32_R_SYM (irel[1].r_info) != r_symndx)
13834             continue;
13835
13836           /* Or if the second next reloc is a LO16 against this symbol too.  */
13837           if (irel + 2 >= irelend
13838               && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
13839               && ELF32_R_SYM (irel[2].r_info) == r_symndx)
13840             continue;
13841
13842           /* See if the LUI instruction *might* be in a branch delay slot.
13843              We check whether what looks like a 16-bit branch or jump is
13844              actually an immediate argument to a compact branch, and let
13845              it through if so.  */
13846           if (irel->r_offset >= 2
13847               && check_br16_dslot (abfd, ptr - 2)
13848               && !(irel->r_offset >= 4
13849                    && (bzc = check_relocated_bzc (abfd,
13850                                                   ptr - 4, irel->r_offset - 4,
13851                                                   internal_relocs, irelend))))
13852             continue;
13853           if (irel->r_offset >= 4
13854               && !bzc
13855               && check_br32_dslot (abfd, ptr - 4))
13856             continue;
13857
13858           reg = OP32_SREG (opcode);
13859
13860           /* We only relax adjacent instructions or ones separated with
13861              a branch or jump that has a delay slot.  The branch or jump
13862              must not fiddle with the register used to hold the address.
13863              Subtract 4 for the LUI itself.  */
13864           offset = irel[1].r_offset - irel[0].r_offset;
13865           switch (offset - 4)
13866             {
13867             case 0:
13868               break;
13869             case 2:
13870               if (check_br16 (abfd, ptr + 4, reg))
13871                 break;
13872               continue;
13873             case 4:
13874               if (check_br32 (abfd, ptr + 4, reg))
13875                 break;
13876               continue;
13877             default:
13878               continue;
13879             }
13880
13881           nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
13882
13883           /* Give up unless the same register is used with both
13884              relocations.  */
13885           if (OP32_SREG (nextopc) != reg)
13886             continue;
13887
13888           /* Now adjust pcrval, subtracting the offset to the LO16 reloc
13889              and rounding up to take masking of the two LSBs into account.  */
13890           pcrval = ((pcrval - offset + 3) | 3) ^ 3;
13891
13892           /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16.  */
13893           if (IS_BITSIZE (symval, 16))
13894             {
13895               /* Fix the relocation's type.  */
13896               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
13897
13898               /* Instructions using R_MICROMIPS_LO16 have the base or
13899                  source register in bits 20:16.  This register becomes $0
13900                  (zero) as the result of the R_MICROMIPS_HI16 being 0.  */
13901               nextopc &= ~0x001f0000;
13902               bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
13903                           contents + irel[1].r_offset);
13904             }
13905
13906           /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
13907              We add 4 to take LUI deletion into account while checking
13908              the PC-relative distance.  */
13909           else if (symval % 4 == 0
13910                    && IS_BITSIZE (pcrval + 4, 25)
13911                    && MATCH (nextopc, addiu_insn)
13912                    && OP32_TREG (nextopc) == OP32_SREG (nextopc)
13913                    && OP16_VALID_REG (OP32_TREG (nextopc)))
13914             {
13915               /* Fix the relocation's type.  */
13916               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
13917
13918               /* Replace ADDIU with the ADDIUPC version.  */
13919               nextopc = (addiupc_insn.match
13920                          | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
13921
13922               bfd_put_micromips_32 (abfd, nextopc,
13923                                     contents + irel[1].r_offset);
13924             }
13925
13926           /* Can't do anything, give up, sigh...  */
13927           else
13928             continue;
13929
13930           /* Fix the relocation's type.  */
13931           irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
13932
13933           /* Delete the LUI instruction: 4 bytes at irel->r_offset.  */
13934           delcnt = 4;
13935           deloff = 0;
13936         }
13937
13938       /* Compact branch relaxation -- due to the multitude of macros
13939          employed by the compiler/assembler, compact branches are not
13940          always generated.  Obviously, this can/will be fixed elsewhere,
13941          but there is no drawback in double checking it here.  */
13942       else if (r_type == R_MICROMIPS_PC16_S1
13943                && irel->r_offset + 5 < sec->size
13944                && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13945                    || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
13946                && ((!insn32
13947                     && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4),
13948                                         nop_insn_16) ? 2 : 0))
13949                    || (irel->r_offset + 7 < sec->size
13950                        && (delcnt = MATCH (bfd_get_micromips_32 (abfd,
13951                                                                  ptr + 4),
13952                                            nop_insn_32) ? 4 : 0))))
13953         {
13954           unsigned long reg;
13955
13956           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13957
13958           /* Replace BEQZ/BNEZ with the compact version.  */
13959           opcode = (bzc_insns_32[fndopc].match
13960                     | BZC32_REG_FIELD (reg)
13961                     | (opcode & 0xffff));               /* Addend value.  */
13962
13963           bfd_put_micromips_32 (abfd, opcode, ptr);
13964
13965           /* Delete the delay slot NOP: two or four bytes from
13966              irel->offset + 4; delcnt has already been set above.  */
13967           deloff = 4;
13968         }
13969
13970       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1.  We need
13971          to check the distance from the next instruction, so subtract 2.  */
13972       else if (!insn32
13973                && r_type == R_MICROMIPS_PC16_S1
13974                && IS_BITSIZE (pcrval - 2, 11)
13975                && find_match (opcode, b_insns_32) >= 0)
13976         {
13977           /* Fix the relocation's type.  */
13978           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
13979
13980           /* Replace the 32-bit opcode with a 16-bit opcode.  */
13981           bfd_put_16 (abfd,
13982                       (b_insn_16.match
13983                        | (opcode & 0x3ff)),             /* Addend value.  */
13984                       ptr);
13985
13986           /* Delete 2 bytes from irel->r_offset + 2.  */
13987           delcnt = 2;
13988           deloff = 2;
13989         }
13990
13991       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1.  We need
13992          to check the distance from the next instruction, so subtract 2.  */
13993       else if (!insn32
13994                && r_type == R_MICROMIPS_PC16_S1
13995                && IS_BITSIZE (pcrval - 2, 8)
13996                && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13997                     && OP16_VALID_REG (OP32_SREG (opcode)))
13998                    || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
13999                        && OP16_VALID_REG (OP32_TREG (opcode)))))
14000         {
14001           unsigned long reg;
14002
14003           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
14004
14005           /* Fix the relocation's type.  */
14006           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
14007
14008           /* Replace the 32-bit opcode with a 16-bit opcode.  */
14009           bfd_put_16 (abfd,
14010                       (bz_insns_16[fndopc].match
14011                        | BZ16_REG_FIELD (reg)
14012                        | (opcode & 0x7f)),              /* Addend value.  */
14013                       ptr);
14014
14015           /* Delete 2 bytes from irel->r_offset + 2.  */
14016           delcnt = 2;
14017           deloff = 2;
14018         }
14019
14020       /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets.  */
14021       else if (!insn32
14022                && r_type == R_MICROMIPS_26_S1
14023                && target_is_micromips_code_p
14024                && irel->r_offset + 7 < sec->size
14025                && MATCH (opcode, jal_insn_32_bd32))
14026         {
14027           unsigned long n32opc;
14028           bfd_boolean relaxed = FALSE;
14029
14030           n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
14031
14032           if (MATCH (n32opc, nop_insn_32))
14033             {
14034               /* Replace delay slot 32-bit NOP with a 16-bit NOP.  */
14035               bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
14036
14037               relaxed = TRUE;
14038             }
14039           else if (find_match (n32opc, move_insns_32) >= 0)
14040             {
14041               /* Replace delay slot 32-bit MOVE with 16-bit MOVE.  */
14042               bfd_put_16 (abfd,
14043                           (move_insn_16.match
14044                            | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
14045                            | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
14046                           ptr + 4);
14047
14048               relaxed = TRUE;
14049             }
14050           /* Other 32-bit instructions relaxable to 16-bit
14051              instructions will be handled here later.  */
14052
14053           if (relaxed)
14054             {
14055               /* JAL with 32-bit delay slot that is changed to a JALS
14056                  with 16-bit delay slot.  */
14057               bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
14058
14059               /* Delete 2 bytes from irel->r_offset + 6.  */
14060               delcnt = 2;
14061               deloff = 6;
14062             }
14063         }
14064
14065       if (delcnt != 0)
14066         {
14067           /* Note that we've changed the relocs, section contents, etc.  */
14068           elf_section_data (sec)->relocs = internal_relocs;
14069           elf_section_data (sec)->this_hdr.contents = contents;
14070           symtab_hdr->contents = (unsigned char *) isymbuf;
14071
14072           /* Delete bytes depending on the delcnt and deloff.  */
14073           if (!mips_elf_relax_delete_bytes (abfd, sec,
14074                                             irel->r_offset + deloff, delcnt))
14075             goto error_return;
14076
14077           /* That will change things, so we should relax again.
14078              Note that this is not required, and it may be slow.  */
14079           *again = TRUE;
14080         }
14081     }
14082
14083   if (isymbuf != NULL
14084       && symtab_hdr->contents != (unsigned char *) isymbuf)
14085     {
14086       if (! link_info->keep_memory)
14087         free (isymbuf);
14088       else
14089         {
14090           /* Cache the symbols for elf_link_input_bfd.  */
14091           symtab_hdr->contents = (unsigned char *) isymbuf;
14092         }
14093     }
14094
14095   if (contents != NULL
14096       && elf_section_data (sec)->this_hdr.contents != contents)
14097     {
14098       if (! link_info->keep_memory)
14099         free (contents);
14100       else
14101         {
14102           /* Cache the section contents for elf_link_input_bfd.  */
14103           elf_section_data (sec)->this_hdr.contents = contents;
14104         }
14105     }
14106
14107   if (internal_relocs != NULL
14108       && elf_section_data (sec)->relocs != internal_relocs)
14109     free (internal_relocs);
14110
14111   return TRUE;
14112
14113  error_return:
14114   if (isymbuf != NULL
14115       && symtab_hdr->contents != (unsigned char *) isymbuf)
14116     free (isymbuf);
14117   if (contents != NULL
14118       && elf_section_data (sec)->this_hdr.contents != contents)
14119     free (contents);
14120   if (internal_relocs != NULL
14121       && elf_section_data (sec)->relocs != internal_relocs)
14122     free (internal_relocs);
14123
14124   return FALSE;
14125 }
14126 \f
14127 /* Create a MIPS ELF linker hash table.  */
14128
14129 struct bfd_link_hash_table *
14130 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
14131 {
14132   struct mips_elf_link_hash_table *ret;
14133   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
14134
14135   ret = bfd_zmalloc (amt);
14136   if (ret == NULL)
14137     return NULL;
14138
14139   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
14140                                       mips_elf_link_hash_newfunc,
14141                                       sizeof (struct mips_elf_link_hash_entry),
14142                                       MIPS_ELF_DATA))
14143     {
14144       free (ret);
14145       return NULL;
14146     }
14147   ret->root.init_plt_refcount.plist = NULL;
14148   ret->root.init_plt_offset.plist = NULL;
14149
14150   return &ret->root.root;
14151 }
14152
14153 /* Likewise, but indicate that the target is VxWorks.  */
14154
14155 struct bfd_link_hash_table *
14156 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
14157 {
14158   struct bfd_link_hash_table *ret;
14159
14160   ret = _bfd_mips_elf_link_hash_table_create (abfd);
14161   if (ret)
14162     {
14163       struct mips_elf_link_hash_table *htab;
14164
14165       htab = (struct mips_elf_link_hash_table *) ret;
14166       htab->use_plts_and_copy_relocs = TRUE;
14167       htab->is_vxworks = TRUE;
14168     }
14169   return ret;
14170 }
14171
14172 /* A function that the linker calls if we are allowed to use PLTs
14173    and copy relocs.  */
14174
14175 void
14176 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
14177 {
14178   mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
14179 }
14180
14181 /* A function that the linker calls to select between all or only
14182    32-bit microMIPS instructions, and between making or ignoring
14183    branch relocation checks for invalid transitions between ISA modes.
14184    Also record whether we have been configured for a GNU target.  */
14185
14186 void
14187 _bfd_mips_elf_linker_flags (struct bfd_link_info *info, bfd_boolean insn32,
14188                             bfd_boolean ignore_branch_isa,
14189                             bfd_boolean gnu_target)
14190 {
14191   mips_elf_hash_table (info)->insn32 = insn32;
14192   mips_elf_hash_table (info)->ignore_branch_isa = ignore_branch_isa;
14193   mips_elf_hash_table (info)->gnu_target = gnu_target;
14194 }
14195 \f
14196 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
14197
14198 struct mips_mach_extension
14199 {
14200   unsigned long extension, base;
14201 };
14202
14203
14204 /* An array describing how BFD machines relate to one another.  The entries
14205    are ordered topologically with MIPS I extensions listed last.  */
14206
14207 static const struct mips_mach_extension mips_mach_extensions[] =
14208 {
14209   /* MIPS64r2 extensions.  */
14210   { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 },
14211   { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
14212   { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
14213   { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
14214   { bfd_mach_mips_gs264e, bfd_mach_mips_gs464e },
14215   { bfd_mach_mips_gs464e, bfd_mach_mips_gs464 },
14216   { bfd_mach_mips_gs464, bfd_mach_mipsisa64r2 },
14217
14218   /* MIPS64 extensions.  */
14219   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
14220   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
14221   { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
14222
14223   /* MIPS V extensions.  */
14224   { bfd_mach_mipsisa64, bfd_mach_mips5 },
14225
14226   /* R10000 extensions.  */
14227   { bfd_mach_mips12000, bfd_mach_mips10000 },
14228   { bfd_mach_mips14000, bfd_mach_mips10000 },
14229   { bfd_mach_mips16000, bfd_mach_mips10000 },
14230
14231   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
14232      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
14233      better to allow vr5400 and vr5500 code to be merged anyway, since
14234      many libraries will just use the core ISA.  Perhaps we could add
14235      some sort of ASE flag if this ever proves a problem.  */
14236   { bfd_mach_mips5500, bfd_mach_mips5400 },
14237   { bfd_mach_mips5400, bfd_mach_mips5000 },
14238
14239   /* MIPS IV extensions.  */
14240   { bfd_mach_mips5, bfd_mach_mips8000 },
14241   { bfd_mach_mips10000, bfd_mach_mips8000 },
14242   { bfd_mach_mips5000, bfd_mach_mips8000 },
14243   { bfd_mach_mips7000, bfd_mach_mips8000 },
14244   { bfd_mach_mips9000, bfd_mach_mips8000 },
14245
14246   /* VR4100 extensions.  */
14247   { bfd_mach_mips4120, bfd_mach_mips4100 },
14248   { bfd_mach_mips4111, bfd_mach_mips4100 },
14249
14250   /* MIPS III extensions.  */
14251   { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
14252   { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
14253   { bfd_mach_mips8000, bfd_mach_mips4000 },
14254   { bfd_mach_mips4650, bfd_mach_mips4000 },
14255   { bfd_mach_mips4600, bfd_mach_mips4000 },
14256   { bfd_mach_mips4400, bfd_mach_mips4000 },
14257   { bfd_mach_mips4300, bfd_mach_mips4000 },
14258   { bfd_mach_mips4100, bfd_mach_mips4000 },
14259   { bfd_mach_mips5900, bfd_mach_mips4000 },
14260
14261   /* MIPS32r3 extensions.  */
14262   { bfd_mach_mips_interaptiv_mr2, bfd_mach_mipsisa32r3 },
14263
14264   /* MIPS32r2 extensions.  */
14265   { bfd_mach_mipsisa32r3, bfd_mach_mipsisa32r2 },
14266
14267   /* MIPS32 extensions.  */
14268   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
14269
14270   /* MIPS II extensions.  */
14271   { bfd_mach_mips4000, bfd_mach_mips6000 },
14272   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
14273   { bfd_mach_mips4010, bfd_mach_mips6000 },
14274
14275   /* MIPS I extensions.  */
14276   { bfd_mach_mips6000, bfd_mach_mips3000 },
14277   { bfd_mach_mips3900, bfd_mach_mips3000 }
14278 };
14279
14280 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
14281
14282 static bfd_boolean
14283 mips_mach_extends_p (unsigned long base, unsigned long extension)
14284 {
14285   size_t i;
14286
14287   if (extension == base)
14288     return TRUE;
14289
14290   if (base == bfd_mach_mipsisa32
14291       && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
14292     return TRUE;
14293
14294   if (base == bfd_mach_mipsisa32r2
14295       && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
14296     return TRUE;
14297
14298   for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
14299     if (extension == mips_mach_extensions[i].extension)
14300       {
14301         extension = mips_mach_extensions[i].base;
14302         if (extension == base)
14303           return TRUE;
14304       }
14305
14306   return FALSE;
14307 }
14308
14309 /* Return the BFD mach for each .MIPS.abiflags ISA Extension.  */
14310
14311 static unsigned long
14312 bfd_mips_isa_ext_mach (unsigned int isa_ext)
14313 {
14314   switch (isa_ext)
14315     {
14316     case AFL_EXT_3900:        return bfd_mach_mips3900;
14317     case AFL_EXT_4010:        return bfd_mach_mips4010;
14318     case AFL_EXT_4100:        return bfd_mach_mips4100;
14319     case AFL_EXT_4111:        return bfd_mach_mips4111;
14320     case AFL_EXT_4120:        return bfd_mach_mips4120;
14321     case AFL_EXT_4650:        return bfd_mach_mips4650;
14322     case AFL_EXT_5400:        return bfd_mach_mips5400;
14323     case AFL_EXT_5500:        return bfd_mach_mips5500;
14324     case AFL_EXT_5900:        return bfd_mach_mips5900;
14325     case AFL_EXT_10000:       return bfd_mach_mips10000;
14326     case AFL_EXT_LOONGSON_2E: return bfd_mach_mips_loongson_2e;
14327     case AFL_EXT_LOONGSON_2F: return bfd_mach_mips_loongson_2f;
14328     case AFL_EXT_SB1:         return bfd_mach_mips_sb1;
14329     case AFL_EXT_OCTEON:      return bfd_mach_mips_octeon;
14330     case AFL_EXT_OCTEONP:     return bfd_mach_mips_octeonp;
14331     case AFL_EXT_OCTEON2:     return bfd_mach_mips_octeon2;
14332     case AFL_EXT_XLR:         return bfd_mach_mips_xlr;
14333     default:                  return bfd_mach_mips3000;
14334     }
14335 }
14336
14337 /* Return the .MIPS.abiflags value representing each ISA Extension.  */
14338
14339 unsigned int
14340 bfd_mips_isa_ext (bfd *abfd)
14341 {
14342   switch (bfd_get_mach (abfd))
14343     {
14344     case bfd_mach_mips3900:         return AFL_EXT_3900;
14345     case bfd_mach_mips4010:         return AFL_EXT_4010;
14346     case bfd_mach_mips4100:         return AFL_EXT_4100;
14347     case bfd_mach_mips4111:         return AFL_EXT_4111;
14348     case bfd_mach_mips4120:         return AFL_EXT_4120;
14349     case bfd_mach_mips4650:         return AFL_EXT_4650;
14350     case bfd_mach_mips5400:         return AFL_EXT_5400;
14351     case bfd_mach_mips5500:         return AFL_EXT_5500;
14352     case bfd_mach_mips5900:         return AFL_EXT_5900;
14353     case bfd_mach_mips10000:        return AFL_EXT_10000;
14354     case bfd_mach_mips_loongson_2e: return AFL_EXT_LOONGSON_2E;
14355     case bfd_mach_mips_loongson_2f: return AFL_EXT_LOONGSON_2F;
14356     case bfd_mach_mips_sb1:         return AFL_EXT_SB1;
14357     case bfd_mach_mips_octeon:      return AFL_EXT_OCTEON;
14358     case bfd_mach_mips_octeonp:     return AFL_EXT_OCTEONP;
14359     case bfd_mach_mips_octeon3:     return AFL_EXT_OCTEON3;
14360     case bfd_mach_mips_octeon2:     return AFL_EXT_OCTEON2;
14361     case bfd_mach_mips_xlr:         return AFL_EXT_XLR;
14362     case bfd_mach_mips_interaptiv_mr2:
14363       return AFL_EXT_INTERAPTIV_MR2;
14364     default:                        return 0;
14365     }
14366 }
14367
14368 /* Encode ISA level and revision as a single value.  */
14369 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14370
14371 /* Decode a single value into level and revision.  */
14372 #define ISA_LEVEL(LEVREV)  ((LEVREV) >> 3)
14373 #define ISA_REV(LEVREV)    ((LEVREV) & 0x7)
14374
14375 /* Update the isa_level, isa_rev, isa_ext fields of abiflags.  */
14376
14377 static void
14378 update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags)
14379 {
14380   int new_isa = 0;
14381   switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
14382     {
14383     case E_MIPS_ARCH_1:    new_isa = LEVEL_REV (1, 0); break;
14384     case E_MIPS_ARCH_2:    new_isa = LEVEL_REV (2, 0); break;
14385     case E_MIPS_ARCH_3:    new_isa = LEVEL_REV (3, 0); break;
14386     case E_MIPS_ARCH_4:    new_isa = LEVEL_REV (4, 0); break;
14387     case E_MIPS_ARCH_5:    new_isa = LEVEL_REV (5, 0); break;
14388     case E_MIPS_ARCH_32:   new_isa = LEVEL_REV (32, 1); break;
14389     case E_MIPS_ARCH_32R2: new_isa = LEVEL_REV (32, 2); break;
14390     case E_MIPS_ARCH_32R6: new_isa = LEVEL_REV (32, 6); break;
14391     case E_MIPS_ARCH_64:   new_isa = LEVEL_REV (64, 1); break;
14392     case E_MIPS_ARCH_64R2: new_isa = LEVEL_REV (64, 2); break;
14393     case E_MIPS_ARCH_64R6: new_isa = LEVEL_REV (64, 6); break;
14394     default:
14395       _bfd_error_handler
14396         /* xgettext:c-format */
14397         (_("%pB: unknown architecture %s"),
14398          abfd, bfd_printable_name (abfd));
14399     }
14400
14401   if (new_isa > LEVEL_REV (abiflags->isa_level, abiflags->isa_rev))
14402     {
14403       abiflags->isa_level = ISA_LEVEL (new_isa);
14404       abiflags->isa_rev = ISA_REV (new_isa);
14405     }
14406
14407   /* Update the isa_ext if ABFD describes a further extension.  */
14408   if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags->isa_ext),
14409                            bfd_get_mach (abfd)))
14410     abiflags->isa_ext = bfd_mips_isa_ext (abfd);
14411 }
14412
14413 /* Return true if the given ELF header flags describe a 32-bit binary.  */
14414
14415 static bfd_boolean
14416 mips_32bit_flags_p (flagword flags)
14417 {
14418   return ((flags & EF_MIPS_32BITMODE) != 0
14419           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
14420           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
14421           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
14422           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
14423           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
14424           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2
14425           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6);
14426 }
14427
14428 /* Infer the content of the ABI flags based on the elf header.  */
14429
14430 static void
14431 infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags)
14432 {
14433   obj_attribute *in_attr;
14434
14435   memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0));
14436   update_mips_abiflags_isa (abfd, abiflags);
14437
14438   if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags))
14439     abiflags->gpr_size = AFL_REG_32;
14440   else
14441     abiflags->gpr_size = AFL_REG_64;
14442
14443   abiflags->cpr1_size = AFL_REG_NONE;
14444
14445   in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
14446   abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14447
14448   if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE
14449       || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX
14450       || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14451           && abiflags->gpr_size == AFL_REG_32))
14452     abiflags->cpr1_size = AFL_REG_32;
14453   else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14454            || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64
14455            || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A)
14456     abiflags->cpr1_size = AFL_REG_64;
14457
14458   abiflags->cpr2_size = AFL_REG_NONE;
14459
14460   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14461     abiflags->ases |= AFL_ASE_MDMX;
14462   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14463     abiflags->ases |= AFL_ASE_MIPS16;
14464   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14465     abiflags->ases |= AFL_ASE_MICROMIPS;
14466
14467   if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY
14468       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT
14469       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A
14470       && abiflags->isa_level >= 32
14471       && abiflags->ases != AFL_ASE_LOONGSON_EXT)
14472     abiflags->flags1 |= AFL_FLAGS1_ODDSPREG;
14473 }
14474
14475 /* We need to use a special link routine to handle the .reginfo and
14476    the .mdebug sections.  We need to merge all instances of these
14477    sections together, not write them all out sequentially.  */
14478
14479 bfd_boolean
14480 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
14481 {
14482   asection *o;
14483   struct bfd_link_order *p;
14484   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
14485   asection *rtproc_sec, *abiflags_sec;
14486   Elf32_RegInfo reginfo;
14487   struct ecoff_debug_info debug;
14488   struct mips_htab_traverse_info hti;
14489   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14490   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
14491   HDRR *symhdr = &debug.symbolic_header;
14492   void *mdebug_handle = NULL;
14493   asection *s;
14494   EXTR esym;
14495   unsigned int i;
14496   bfd_size_type amt;
14497   struct mips_elf_link_hash_table *htab;
14498
14499   static const char * const secname[] =
14500   {
14501     ".text", ".init", ".fini", ".data",
14502     ".rodata", ".sdata", ".sbss", ".bss"
14503   };
14504   static const int sc[] =
14505   {
14506     scText, scInit, scFini, scData,
14507     scRData, scSData, scSBss, scBss
14508   };
14509
14510   htab = mips_elf_hash_table (info);
14511   BFD_ASSERT (htab != NULL);
14512
14513   /* Sort the dynamic symbols so that those with GOT entries come after
14514      those without.  */
14515   if (!mips_elf_sort_hash_table (abfd, info))
14516     return FALSE;
14517
14518   /* Create any scheduled LA25 stubs.  */
14519   hti.info = info;
14520   hti.output_bfd = abfd;
14521   hti.error = FALSE;
14522   htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
14523   if (hti.error)
14524     return FALSE;
14525
14526   /* Get a value for the GP register.  */
14527   if (elf_gp (abfd) == 0)
14528     {
14529       struct bfd_link_hash_entry *h;
14530
14531       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
14532       if (h != NULL && h->type == bfd_link_hash_defined)
14533         elf_gp (abfd) = (h->u.def.value
14534                          + h->u.def.section->output_section->vma
14535                          + h->u.def.section->output_offset);
14536       else if (htab->is_vxworks
14537                && (h = bfd_link_hash_lookup (info->hash,
14538                                              "_GLOBAL_OFFSET_TABLE_",
14539                                              FALSE, FALSE, TRUE))
14540                && h->type == bfd_link_hash_defined)
14541         elf_gp (abfd) = (h->u.def.section->output_section->vma
14542                          + h->u.def.section->output_offset
14543                          + h->u.def.value);
14544       else if (bfd_link_relocatable (info))
14545         {
14546           bfd_vma lo = MINUS_ONE;
14547
14548           /* Find the GP-relative section with the lowest offset.  */
14549           for (o = abfd->sections; o != NULL; o = o->next)
14550             if (o->vma < lo
14551                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
14552               lo = o->vma;
14553
14554           /* And calculate GP relative to that.  */
14555           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
14556         }
14557       else
14558         {
14559           /* If the relocate_section function needs to do a reloc
14560              involving the GP value, it should make a reloc_dangerous
14561              callback to warn that GP is not defined.  */
14562         }
14563     }
14564
14565   /* Go through the sections and collect the .reginfo and .mdebug
14566      information.  */
14567   abiflags_sec = NULL;
14568   reginfo_sec = NULL;
14569   mdebug_sec = NULL;
14570   gptab_data_sec = NULL;
14571   gptab_bss_sec = NULL;
14572   for (o = abfd->sections; o != NULL; o = o->next)
14573     {
14574       if (strcmp (o->name, ".MIPS.abiflags") == 0)
14575         {
14576           /* We have found the .MIPS.abiflags section in the output file.
14577              Look through all the link_orders comprising it and remove them.
14578              The data is merged in _bfd_mips_elf_merge_private_bfd_data.  */
14579           for (p = o->map_head.link_order; p != NULL; p = p->next)
14580             {
14581               asection *input_section;
14582
14583               if (p->type != bfd_indirect_link_order)
14584                 {
14585                   if (p->type == bfd_data_link_order)
14586                     continue;
14587                   abort ();
14588                 }
14589
14590               input_section = p->u.indirect.section;
14591
14592               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14593                  elf_link_input_bfd ignores this section.  */
14594               input_section->flags &= ~SEC_HAS_CONTENTS;
14595             }
14596
14597           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
14598           BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0));
14599
14600           /* Skip this section later on (I don't think this currently
14601              matters, but someday it might).  */
14602           o->map_head.link_order = NULL;
14603
14604           abiflags_sec = o;
14605         }
14606
14607       if (strcmp (o->name, ".reginfo") == 0)
14608         {
14609           memset (&reginfo, 0, sizeof reginfo);
14610
14611           /* We have found the .reginfo section in the output file.
14612              Look through all the link_orders comprising it and merge
14613              the information together.  */
14614           for (p = o->map_head.link_order; p != NULL; p = p->next)
14615             {
14616               asection *input_section;
14617               bfd *input_bfd;
14618               Elf32_External_RegInfo ext;
14619               Elf32_RegInfo sub;
14620               bfd_size_type sz;
14621
14622               if (p->type != bfd_indirect_link_order)
14623                 {
14624                   if (p->type == bfd_data_link_order)
14625                     continue;
14626                   abort ();
14627                 }
14628
14629               input_section = p->u.indirect.section;
14630               input_bfd = input_section->owner;
14631
14632               sz = (input_section->size < sizeof (ext)
14633                     ? input_section->size : sizeof (ext));
14634               memset (&ext, 0, sizeof (ext));
14635               if (! bfd_get_section_contents (input_bfd, input_section,
14636                                               &ext, 0, sz))
14637                 return FALSE;
14638
14639               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
14640
14641               reginfo.ri_gprmask |= sub.ri_gprmask;
14642               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
14643               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
14644               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
14645               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
14646
14647               /* ri_gp_value is set by the function
14648                  `_bfd_mips_elf_section_processing' when the section is
14649                  finally written out.  */
14650
14651               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14652                  elf_link_input_bfd ignores this section.  */
14653               input_section->flags &= ~SEC_HAS_CONTENTS;
14654             }
14655
14656           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
14657           BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
14658
14659           /* Skip this section later on (I don't think this currently
14660              matters, but someday it might).  */
14661           o->map_head.link_order = NULL;
14662
14663           reginfo_sec = o;
14664         }
14665
14666       if (strcmp (o->name, ".mdebug") == 0)
14667         {
14668           struct extsym_info einfo;
14669           bfd_vma last;
14670
14671           /* We have found the .mdebug section in the output file.
14672              Look through all the link_orders comprising it and merge
14673              the information together.  */
14674           symhdr->magic = swap->sym_magic;
14675           /* FIXME: What should the version stamp be?  */
14676           symhdr->vstamp = 0;
14677           symhdr->ilineMax = 0;
14678           symhdr->cbLine = 0;
14679           symhdr->idnMax = 0;
14680           symhdr->ipdMax = 0;
14681           symhdr->isymMax = 0;
14682           symhdr->ioptMax = 0;
14683           symhdr->iauxMax = 0;
14684           symhdr->issMax = 0;
14685           symhdr->issExtMax = 0;
14686           symhdr->ifdMax = 0;
14687           symhdr->crfd = 0;
14688           symhdr->iextMax = 0;
14689
14690           /* We accumulate the debugging information itself in the
14691              debug_info structure.  */
14692           debug.line = NULL;
14693           debug.external_dnr = NULL;
14694           debug.external_pdr = NULL;
14695           debug.external_sym = NULL;
14696           debug.external_opt = NULL;
14697           debug.external_aux = NULL;
14698           debug.ss = NULL;
14699           debug.ssext = debug.ssext_end = NULL;
14700           debug.external_fdr = NULL;
14701           debug.external_rfd = NULL;
14702           debug.external_ext = debug.external_ext_end = NULL;
14703
14704           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
14705           if (mdebug_handle == NULL)
14706             return FALSE;
14707
14708           esym.jmptbl = 0;
14709           esym.cobol_main = 0;
14710           esym.weakext = 0;
14711           esym.reserved = 0;
14712           esym.ifd = ifdNil;
14713           esym.asym.iss = issNil;
14714           esym.asym.st = stLocal;
14715           esym.asym.reserved = 0;
14716           esym.asym.index = indexNil;
14717           last = 0;
14718           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
14719             {
14720               esym.asym.sc = sc[i];
14721               s = bfd_get_section_by_name (abfd, secname[i]);
14722               if (s != NULL)
14723                 {
14724                   esym.asym.value = s->vma;
14725                   last = s->vma + s->size;
14726                 }
14727               else
14728                 esym.asym.value = last;
14729               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
14730                                                  secname[i], &esym))
14731                 return FALSE;
14732             }
14733
14734           for (p = o->map_head.link_order; p != NULL; p = p->next)
14735             {
14736               asection *input_section;
14737               bfd *input_bfd;
14738               const struct ecoff_debug_swap *input_swap;
14739               struct ecoff_debug_info input_debug;
14740               char *eraw_src;
14741               char *eraw_end;
14742
14743               if (p->type != bfd_indirect_link_order)
14744                 {
14745                   if (p->type == bfd_data_link_order)
14746                     continue;
14747                   abort ();
14748                 }
14749
14750               input_section = p->u.indirect.section;
14751               input_bfd = input_section->owner;
14752
14753               if (!is_mips_elf (input_bfd))
14754                 {
14755                   /* I don't know what a non MIPS ELF bfd would be
14756                      doing with a .mdebug section, but I don't really
14757                      want to deal with it.  */
14758                   continue;
14759                 }
14760
14761               input_swap = (get_elf_backend_data (input_bfd)
14762                             ->elf_backend_ecoff_debug_swap);
14763
14764               BFD_ASSERT (p->size == input_section->size);
14765
14766               /* The ECOFF linking code expects that we have already
14767                  read in the debugging information and set up an
14768                  ecoff_debug_info structure, so we do that now.  */
14769               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
14770                                                    &input_debug))
14771                 return FALSE;
14772
14773               if (! (bfd_ecoff_debug_accumulate
14774                      (mdebug_handle, abfd, &debug, swap, input_bfd,
14775                       &input_debug, input_swap, info)))
14776                 return FALSE;
14777
14778               /* Loop through the external symbols.  For each one with
14779                  interesting information, try to find the symbol in
14780                  the linker global hash table and save the information
14781                  for the output external symbols.  */
14782               eraw_src = input_debug.external_ext;
14783               eraw_end = (eraw_src
14784                           + (input_debug.symbolic_header.iextMax
14785                              * input_swap->external_ext_size));
14786               for (;
14787                    eraw_src < eraw_end;
14788                    eraw_src += input_swap->external_ext_size)
14789                 {
14790                   EXTR ext;
14791                   const char *name;
14792                   struct mips_elf_link_hash_entry *h;
14793
14794                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
14795                   if (ext.asym.sc == scNil
14796                       || ext.asym.sc == scUndefined
14797                       || ext.asym.sc == scSUndefined)
14798                     continue;
14799
14800                   name = input_debug.ssext + ext.asym.iss;
14801                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
14802                                                  name, FALSE, FALSE, TRUE);
14803                   if (h == NULL || h->esym.ifd != -2)
14804                     continue;
14805
14806                   if (ext.ifd != -1)
14807                     {
14808                       BFD_ASSERT (ext.ifd
14809                                   < input_debug.symbolic_header.ifdMax);
14810                       ext.ifd = input_debug.ifdmap[ext.ifd];
14811                     }
14812
14813                   h->esym = ext;
14814                 }
14815
14816               /* Free up the information we just read.  */
14817               free (input_debug.line);
14818               free (input_debug.external_dnr);
14819               free (input_debug.external_pdr);
14820               free (input_debug.external_sym);
14821               free (input_debug.external_opt);
14822               free (input_debug.external_aux);
14823               free (input_debug.ss);
14824               free (input_debug.ssext);
14825               free (input_debug.external_fdr);
14826               free (input_debug.external_rfd);
14827               free (input_debug.external_ext);
14828
14829               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14830                  elf_link_input_bfd ignores this section.  */
14831               input_section->flags &= ~SEC_HAS_CONTENTS;
14832             }
14833
14834           if (SGI_COMPAT (abfd) && bfd_link_pic (info))
14835             {
14836               /* Create .rtproc section.  */
14837               rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
14838               if (rtproc_sec == NULL)
14839                 {
14840                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
14841                                     | SEC_LINKER_CREATED | SEC_READONLY);
14842
14843                   rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
14844                                                                    ".rtproc",
14845                                                                    flags);
14846                   if (rtproc_sec == NULL
14847                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
14848                     return FALSE;
14849                 }
14850
14851               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
14852                                                      info, rtproc_sec,
14853                                                      &debug))
14854                 return FALSE;
14855             }
14856
14857           /* Build the external symbol information.  */
14858           einfo.abfd = abfd;
14859           einfo.info = info;
14860           einfo.debug = &debug;
14861           einfo.swap = swap;
14862           einfo.failed = FALSE;
14863           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
14864                                        mips_elf_output_extsym, &einfo);
14865           if (einfo.failed)
14866             return FALSE;
14867
14868           /* Set the size of the .mdebug section.  */
14869           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
14870
14871           /* Skip this section later on (I don't think this currently
14872              matters, but someday it might).  */
14873           o->map_head.link_order = NULL;
14874
14875           mdebug_sec = o;
14876         }
14877
14878       if (CONST_STRNEQ (o->name, ".gptab."))
14879         {
14880           const char *subname;
14881           unsigned int c;
14882           Elf32_gptab *tab;
14883           Elf32_External_gptab *ext_tab;
14884           unsigned int j;
14885
14886           /* The .gptab.sdata and .gptab.sbss sections hold
14887              information describing how the small data area would
14888              change depending upon the -G switch.  These sections
14889              not used in executables files.  */
14890           if (! bfd_link_relocatable (info))
14891             {
14892               for (p = o->map_head.link_order; p != NULL; p = p->next)
14893                 {
14894                   asection *input_section;
14895
14896                   if (p->type != bfd_indirect_link_order)
14897                     {
14898                       if (p->type == bfd_data_link_order)
14899                         continue;
14900                       abort ();
14901                     }
14902
14903                   input_section = p->u.indirect.section;
14904
14905                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
14906                      elf_link_input_bfd ignores this section.  */
14907                   input_section->flags &= ~SEC_HAS_CONTENTS;
14908                 }
14909
14910               /* Skip this section later on (I don't think this
14911                  currently matters, but someday it might).  */
14912               o->map_head.link_order = NULL;
14913
14914               /* Really remove the section.  */
14915               bfd_section_list_remove (abfd, o);
14916               --abfd->section_count;
14917
14918               continue;
14919             }
14920
14921           /* There is one gptab for initialized data, and one for
14922              uninitialized data.  */
14923           if (strcmp (o->name, ".gptab.sdata") == 0)
14924             gptab_data_sec = o;
14925           else if (strcmp (o->name, ".gptab.sbss") == 0)
14926             gptab_bss_sec = o;
14927           else
14928             {
14929               _bfd_error_handler
14930                 /* xgettext:c-format */
14931                 (_("%pB: illegal section name `%pA'"), abfd, o);
14932               bfd_set_error (bfd_error_nonrepresentable_section);
14933               return FALSE;
14934             }
14935
14936           /* The linker script always combines .gptab.data and
14937              .gptab.sdata into .gptab.sdata, and likewise for
14938              .gptab.bss and .gptab.sbss.  It is possible that there is
14939              no .sdata or .sbss section in the output file, in which
14940              case we must change the name of the output section.  */
14941           subname = o->name + sizeof ".gptab" - 1;
14942           if (bfd_get_section_by_name (abfd, subname) == NULL)
14943             {
14944               if (o == gptab_data_sec)
14945                 o->name = ".gptab.data";
14946               else
14947                 o->name = ".gptab.bss";
14948               subname = o->name + sizeof ".gptab" - 1;
14949               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
14950             }
14951
14952           /* Set up the first entry.  */
14953           c = 1;
14954           amt = c * sizeof (Elf32_gptab);
14955           tab = bfd_malloc (amt);
14956           if (tab == NULL)
14957             return FALSE;
14958           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
14959           tab[0].gt_header.gt_unused = 0;
14960
14961           /* Combine the input sections.  */
14962           for (p = o->map_head.link_order; p != NULL; p = p->next)
14963             {
14964               asection *input_section;
14965               bfd *input_bfd;
14966               bfd_size_type size;
14967               unsigned long last;
14968               bfd_size_type gpentry;
14969
14970               if (p->type != bfd_indirect_link_order)
14971                 {
14972                   if (p->type == bfd_data_link_order)
14973                     continue;
14974                   abort ();
14975                 }
14976
14977               input_section = p->u.indirect.section;
14978               input_bfd = input_section->owner;
14979
14980               /* Combine the gptab entries for this input section one
14981                  by one.  We know that the input gptab entries are
14982                  sorted by ascending -G value.  */
14983               size = input_section->size;
14984               last = 0;
14985               for (gpentry = sizeof (Elf32_External_gptab);
14986                    gpentry < size;
14987                    gpentry += sizeof (Elf32_External_gptab))
14988                 {
14989                   Elf32_External_gptab ext_gptab;
14990                   Elf32_gptab int_gptab;
14991                   unsigned long val;
14992                   unsigned long add;
14993                   bfd_boolean exact;
14994                   unsigned int look;
14995
14996                   if (! (bfd_get_section_contents
14997                          (input_bfd, input_section, &ext_gptab, gpentry,
14998                           sizeof (Elf32_External_gptab))))
14999                     {
15000                       free (tab);
15001                       return FALSE;
15002                     }
15003
15004                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
15005                                                 &int_gptab);
15006                   val = int_gptab.gt_entry.gt_g_value;
15007                   add = int_gptab.gt_entry.gt_bytes - last;
15008
15009                   exact = FALSE;
15010                   for (look = 1; look < c; look++)
15011                     {
15012                       if (tab[look].gt_entry.gt_g_value >= val)
15013                         tab[look].gt_entry.gt_bytes += add;
15014
15015                       if (tab[look].gt_entry.gt_g_value == val)
15016                         exact = TRUE;
15017                     }
15018
15019                   if (! exact)
15020                     {
15021                       Elf32_gptab *new_tab;
15022                       unsigned int max;
15023
15024                       /* We need a new table entry.  */
15025                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
15026                       new_tab = bfd_realloc (tab, amt);
15027                       if (new_tab == NULL)
15028                         {
15029                           free (tab);
15030                           return FALSE;
15031                         }
15032                       tab = new_tab;
15033                       tab[c].gt_entry.gt_g_value = val;
15034                       tab[c].gt_entry.gt_bytes = add;
15035
15036                       /* Merge in the size for the next smallest -G
15037                          value, since that will be implied by this new
15038                          value.  */
15039                       max = 0;
15040                       for (look = 1; look < c; look++)
15041                         {
15042                           if (tab[look].gt_entry.gt_g_value < val
15043                               && (max == 0
15044                                   || (tab[look].gt_entry.gt_g_value
15045                                       > tab[max].gt_entry.gt_g_value)))
15046                             max = look;
15047                         }
15048                       if (max != 0)
15049                         tab[c].gt_entry.gt_bytes +=
15050                           tab[max].gt_entry.gt_bytes;
15051
15052                       ++c;
15053                     }
15054
15055                   last = int_gptab.gt_entry.gt_bytes;
15056                 }
15057
15058               /* Hack: reset the SEC_HAS_CONTENTS flag so that
15059                  elf_link_input_bfd ignores this section.  */
15060               input_section->flags &= ~SEC_HAS_CONTENTS;
15061             }
15062
15063           /* The table must be sorted by -G value.  */
15064           if (c > 2)
15065             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
15066
15067           /* Swap out the table.  */
15068           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
15069           ext_tab = bfd_alloc (abfd, amt);
15070           if (ext_tab == NULL)
15071             {
15072               free (tab);
15073               return FALSE;
15074             }
15075
15076           for (j = 0; j < c; j++)
15077             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
15078           free (tab);
15079
15080           o->size = c * sizeof (Elf32_External_gptab);
15081           o->contents = (bfd_byte *) ext_tab;
15082
15083           /* Skip this section later on (I don't think this currently
15084              matters, but someday it might).  */
15085           o->map_head.link_order = NULL;
15086         }
15087     }
15088
15089   /* Invoke the regular ELF backend linker to do all the work.  */
15090   if (!bfd_elf_final_link (abfd, info))
15091     return FALSE;
15092
15093   /* Now write out the computed sections.  */
15094
15095   if (abiflags_sec != NULL)
15096     {
15097       Elf_External_ABIFlags_v0 ext;
15098       Elf_Internal_ABIFlags_v0 *abiflags;
15099
15100       abiflags = &mips_elf_tdata (abfd)->abiflags;
15101
15102       /* Set up the abiflags if no valid input sections were found.  */
15103       if (!mips_elf_tdata (abfd)->abiflags_valid)
15104         {
15105           infer_mips_abiflags (abfd, abiflags);
15106           mips_elf_tdata (abfd)->abiflags_valid = TRUE;
15107         }
15108       bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext);
15109       if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext))
15110         return FALSE;
15111     }
15112
15113   if (reginfo_sec != NULL)
15114     {
15115       Elf32_External_RegInfo ext;
15116
15117       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
15118       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
15119         return FALSE;
15120     }
15121
15122   if (mdebug_sec != NULL)
15123     {
15124       BFD_ASSERT (abfd->output_has_begun);
15125       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
15126                                                swap, info,
15127                                                mdebug_sec->filepos))
15128         return FALSE;
15129
15130       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
15131     }
15132
15133   if (gptab_data_sec != NULL)
15134     {
15135       if (! bfd_set_section_contents (abfd, gptab_data_sec,
15136                                       gptab_data_sec->contents,
15137                                       0, gptab_data_sec->size))
15138         return FALSE;
15139     }
15140
15141   if (gptab_bss_sec != NULL)
15142     {
15143       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
15144                                       gptab_bss_sec->contents,
15145                                       0, gptab_bss_sec->size))
15146         return FALSE;
15147     }
15148
15149   if (SGI_COMPAT (abfd))
15150     {
15151       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
15152       if (rtproc_sec != NULL)
15153         {
15154           if (! bfd_set_section_contents (abfd, rtproc_sec,
15155                                           rtproc_sec->contents,
15156                                           0, rtproc_sec->size))
15157             return FALSE;
15158         }
15159     }
15160
15161   return TRUE;
15162 }
15163 \f
15164 /* Merge object file header flags from IBFD into OBFD.  Raise an error
15165    if there are conflicting settings.  */
15166
15167 static bfd_boolean
15168 mips_elf_merge_obj_e_flags (bfd *ibfd, struct bfd_link_info *info)
15169 {
15170   bfd *obfd = info->output_bfd;
15171   struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15172   flagword old_flags;
15173   flagword new_flags;
15174   bfd_boolean ok;
15175
15176   new_flags = elf_elfheader (ibfd)->e_flags;
15177   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
15178   old_flags = elf_elfheader (obfd)->e_flags;
15179
15180   /* Check flag compatibility.  */
15181
15182   new_flags &= ~EF_MIPS_NOREORDER;
15183   old_flags &= ~EF_MIPS_NOREORDER;
15184
15185   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
15186      doesn't seem to matter.  */
15187   new_flags &= ~EF_MIPS_XGOT;
15188   old_flags &= ~EF_MIPS_XGOT;
15189
15190   /* MIPSpro generates ucode info in n64 objects.  Again, we should
15191      just be able to ignore this.  */
15192   new_flags &= ~EF_MIPS_UCODE;
15193   old_flags &= ~EF_MIPS_UCODE;
15194
15195   /* DSOs should only be linked with CPIC code.  */
15196   if ((ibfd->flags & DYNAMIC) != 0)
15197     new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
15198
15199   if (new_flags == old_flags)
15200     return TRUE;
15201
15202   ok = TRUE;
15203
15204   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
15205       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
15206     {
15207       _bfd_error_handler
15208         (_("%pB: warning: linking abicalls files with non-abicalls files"),
15209          ibfd);
15210       ok = TRUE;
15211     }
15212
15213   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
15214     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
15215   if (! (new_flags & EF_MIPS_PIC))
15216     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
15217
15218   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15219   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15220
15221   /* Compare the ISAs.  */
15222   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
15223     {
15224       _bfd_error_handler
15225         (_("%pB: linking 32-bit code with 64-bit code"),
15226          ibfd);
15227       ok = FALSE;
15228     }
15229   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
15230     {
15231       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
15232       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
15233         {
15234           /* Copy the architecture info from IBFD to OBFD.  Also copy
15235              the 32-bit flag (if set) so that we continue to recognise
15236              OBFD as a 32-bit binary.  */
15237           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
15238           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
15239           elf_elfheader (obfd)->e_flags
15240             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15241
15242           /* Update the ABI flags isa_level, isa_rev, isa_ext fields.  */
15243           update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15244
15245           /* Copy across the ABI flags if OBFD doesn't use them
15246              and if that was what caused us to treat IBFD as 32-bit.  */
15247           if ((old_flags & EF_MIPS_ABI) == 0
15248               && mips_32bit_flags_p (new_flags)
15249               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
15250             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
15251         }
15252       else
15253         {
15254           /* The ISAs aren't compatible.  */
15255           _bfd_error_handler
15256             /* xgettext:c-format */
15257             (_("%pB: linking %s module with previous %s modules"),
15258              ibfd,
15259              bfd_printable_name (ibfd),
15260              bfd_printable_name (obfd));
15261           ok = FALSE;
15262         }
15263     }
15264
15265   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15266   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15267
15268   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
15269      does set EI_CLASS differently from any 32-bit ABI.  */
15270   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
15271       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15272           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15273     {
15274       /* Only error if both are set (to different values).  */
15275       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
15276           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15277               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15278         {
15279           _bfd_error_handler
15280             /* xgettext:c-format */
15281             (_("%pB: ABI mismatch: linking %s module with previous %s modules"),
15282              ibfd,
15283              elf_mips_abi_name (ibfd),
15284              elf_mips_abi_name (obfd));
15285           ok = FALSE;
15286         }
15287       new_flags &= ~EF_MIPS_ABI;
15288       old_flags &= ~EF_MIPS_ABI;
15289     }
15290
15291   /* Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
15292      and allow arbitrary mixing of the remaining ASEs (retain the union).  */
15293   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
15294     {
15295       int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15296       int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15297       int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
15298       int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
15299       int micro_mis = old_m16 && new_micro;
15300       int m16_mis = old_micro && new_m16;
15301
15302       if (m16_mis || micro_mis)
15303         {
15304           _bfd_error_handler
15305             /* xgettext:c-format */
15306             (_("%pB: ASE mismatch: linking %s module with previous %s modules"),
15307              ibfd,
15308              m16_mis ? "MIPS16" : "microMIPS",
15309              m16_mis ? "microMIPS" : "MIPS16");
15310           ok = FALSE;
15311         }
15312
15313       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
15314
15315       new_flags &= ~ EF_MIPS_ARCH_ASE;
15316       old_flags &= ~ EF_MIPS_ARCH_ASE;
15317     }
15318
15319   /* Compare NaN encodings.  */
15320   if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
15321     {
15322       /* xgettext:c-format */
15323       _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15324                           ibfd,
15325                           (new_flags & EF_MIPS_NAN2008
15326                            ? "-mnan=2008" : "-mnan=legacy"),
15327                           (old_flags & EF_MIPS_NAN2008
15328                            ? "-mnan=2008" : "-mnan=legacy"));
15329       ok = FALSE;
15330       new_flags &= ~EF_MIPS_NAN2008;
15331       old_flags &= ~EF_MIPS_NAN2008;
15332     }
15333
15334   /* Compare FP64 state.  */
15335   if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
15336     {
15337       /* xgettext:c-format */
15338       _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15339                           ibfd,
15340                           (new_flags & EF_MIPS_FP64
15341                            ? "-mfp64" : "-mfp32"),
15342                           (old_flags & EF_MIPS_FP64
15343                            ? "-mfp64" : "-mfp32"));
15344       ok = FALSE;
15345       new_flags &= ~EF_MIPS_FP64;
15346       old_flags &= ~EF_MIPS_FP64;
15347     }
15348
15349   /* Warn about any other mismatches */
15350   if (new_flags != old_flags)
15351     {
15352       /* xgettext:c-format */
15353       _bfd_error_handler
15354         (_("%pB: uses different e_flags (%#x) fields than previous modules "
15355            "(%#x)"),
15356          ibfd, new_flags, old_flags);
15357       ok = FALSE;
15358     }
15359
15360   return ok;
15361 }
15362
15363 /* Merge object attributes from IBFD into OBFD.  Raise an error if
15364    there are conflicting attributes.  */
15365 static bfd_boolean
15366 mips_elf_merge_obj_attributes (bfd *ibfd, struct bfd_link_info *info)
15367 {
15368   bfd *obfd = info->output_bfd;
15369   obj_attribute *in_attr;
15370   obj_attribute *out_attr;
15371   bfd *abi_fp_bfd;
15372   bfd *abi_msa_bfd;
15373
15374   abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
15375   in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15376   if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY)
15377     mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15378
15379   abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd;
15380   if (!abi_msa_bfd
15381       && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15382     mips_elf_tdata (obfd)->abi_msa_bfd = ibfd;
15383
15384   if (!elf_known_obj_attributes_proc (obfd)[0].i)
15385     {
15386       /* This is the first object.  Copy the attributes.  */
15387       _bfd_elf_copy_obj_attributes (ibfd, obfd);
15388
15389       /* Use the Tag_null value to indicate the attributes have been
15390          initialized.  */
15391       elf_known_obj_attributes_proc (obfd)[0].i = 1;
15392
15393       return TRUE;
15394     }
15395
15396   /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
15397      non-conflicting ones.  */
15398   out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15399   if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
15400     {
15401       int out_fp, in_fp;
15402
15403       out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15404       in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15405       out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
15406       if (out_fp == Val_GNU_MIPS_ABI_FP_ANY)
15407         out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp;
15408       else if (out_fp == Val_GNU_MIPS_ABI_FP_XX
15409                && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15410                    || in_fp == Val_GNU_MIPS_ABI_FP_64
15411                    || in_fp == Val_GNU_MIPS_ABI_FP_64A))
15412         {
15413           mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15414           out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15415         }
15416       else if (in_fp == Val_GNU_MIPS_ABI_FP_XX
15417                && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15418                    || out_fp == Val_GNU_MIPS_ABI_FP_64
15419                    || out_fp == Val_GNU_MIPS_ABI_FP_64A))
15420         /* Keep the current setting.  */;
15421       else if (out_fp == Val_GNU_MIPS_ABI_FP_64A
15422                && in_fp == Val_GNU_MIPS_ABI_FP_64)
15423         {
15424           mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15425           out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15426         }
15427       else if (in_fp == Val_GNU_MIPS_ABI_FP_64A
15428                && out_fp == Val_GNU_MIPS_ABI_FP_64)
15429         /* Keep the current setting.  */;
15430       else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY)
15431         {
15432           const char *out_string, *in_string;
15433
15434           out_string = _bfd_mips_fp_abi_string (out_fp);
15435           in_string = _bfd_mips_fp_abi_string (in_fp);
15436           /* First warn about cases involving unrecognised ABIs.  */
15437           if (!out_string && !in_string)
15438             /* xgettext:c-format */
15439             _bfd_error_handler
15440               (_("warning: %pB uses unknown floating point ABI %d "
15441                  "(set by %pB), %pB uses unknown floating point ABI %d"),
15442                obfd, out_fp, abi_fp_bfd, ibfd, in_fp);
15443           else if (!out_string)
15444             _bfd_error_handler
15445               /* xgettext:c-format */
15446               (_("warning: %pB uses unknown floating point ABI %d "
15447                  "(set by %pB), %pB uses %s"),
15448                obfd, out_fp, abi_fp_bfd, ibfd, in_string);
15449           else if (!in_string)
15450             _bfd_error_handler
15451               /* xgettext:c-format */
15452               (_("warning: %pB uses %s (set by %pB), "
15453                  "%pB uses unknown floating point ABI %d"),
15454                obfd, out_string, abi_fp_bfd, ibfd, in_fp);
15455           else
15456             {
15457               /* If one of the bfds is soft-float, the other must be
15458                  hard-float.  The exact choice of hard-float ABI isn't
15459                  really relevant to the error message.  */
15460               if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15461                 out_string = "-mhard-float";
15462               else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15463                 in_string = "-mhard-float";
15464               _bfd_error_handler
15465                 /* xgettext:c-format */
15466                 (_("warning: %pB uses %s (set by %pB), %pB uses %s"),
15467                  obfd, out_string, abi_fp_bfd, ibfd, in_string);
15468             }
15469         }
15470     }
15471
15472   /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15473      non-conflicting ones.  */
15474   if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15475     {
15476       out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1;
15477       if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY)
15478         out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i;
15479       else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15480         switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15481           {
15482           case Val_GNU_MIPS_ABI_MSA_128:
15483             _bfd_error_handler
15484               /* xgettext:c-format */
15485               (_("warning: %pB uses %s (set by %pB), "
15486                  "%pB uses unknown MSA ABI %d"),
15487                obfd, "-mmsa", abi_msa_bfd,
15488                ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15489             break;
15490
15491           default:
15492             switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i)
15493               {
15494               case Val_GNU_MIPS_ABI_MSA_128:
15495                 _bfd_error_handler
15496                   /* xgettext:c-format */
15497                   (_("warning: %pB uses unknown MSA ABI %d "
15498                      "(set by %pB), %pB uses %s"),
15499                      obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i,
15500                    abi_msa_bfd, ibfd, "-mmsa");
15501                   break;
15502
15503               default:
15504                 _bfd_error_handler
15505                   /* xgettext:c-format */
15506                   (_("warning: %pB uses unknown MSA ABI %d "
15507                      "(set by %pB), %pB uses unknown MSA ABI %d"),
15508                    obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i,
15509                    abi_msa_bfd, ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15510                 break;
15511               }
15512           }
15513     }
15514
15515   /* Merge Tag_compatibility attributes and any common GNU ones.  */
15516   return _bfd_elf_merge_object_attributes (ibfd, info);
15517 }
15518
15519 /* Merge object ABI flags from IBFD into OBFD.  Raise an error if
15520    there are conflicting settings.  */
15521
15522 static bfd_boolean
15523 mips_elf_merge_obj_abiflags (bfd *ibfd, bfd *obfd)
15524 {
15525   obj_attribute *out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15526   struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15527   struct mips_elf_obj_tdata *in_tdata = mips_elf_tdata (ibfd);
15528
15529   /* Update the output abiflags fp_abi using the computed fp_abi.  */
15530   out_tdata->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15531
15532 #define max(a, b) ((a) > (b) ? (a) : (b))
15533   /* Merge abiflags.  */
15534   out_tdata->abiflags.isa_level = max (out_tdata->abiflags.isa_level,
15535                                        in_tdata->abiflags.isa_level);
15536   out_tdata->abiflags.isa_rev = max (out_tdata->abiflags.isa_rev,
15537                                      in_tdata->abiflags.isa_rev);
15538   out_tdata->abiflags.gpr_size = max (out_tdata->abiflags.gpr_size,
15539                                       in_tdata->abiflags.gpr_size);
15540   out_tdata->abiflags.cpr1_size = max (out_tdata->abiflags.cpr1_size,
15541                                        in_tdata->abiflags.cpr1_size);
15542   out_tdata->abiflags.cpr2_size = max (out_tdata->abiflags.cpr2_size,
15543                                        in_tdata->abiflags.cpr2_size);
15544 #undef max
15545   out_tdata->abiflags.ases |= in_tdata->abiflags.ases;
15546   out_tdata->abiflags.flags1 |= in_tdata->abiflags.flags1;
15547
15548   return TRUE;
15549 }
15550
15551 /* Merge backend specific data from an object file to the output
15552    object file when linking.  */
15553
15554 bfd_boolean
15555 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
15556 {
15557   bfd *obfd = info->output_bfd;
15558   struct mips_elf_obj_tdata *out_tdata;
15559   struct mips_elf_obj_tdata *in_tdata;
15560   bfd_boolean null_input_bfd = TRUE;
15561   asection *sec;
15562   bfd_boolean ok;
15563
15564   /* Check if we have the same endianness.  */
15565   if (! _bfd_generic_verify_endian_match (ibfd, info))
15566     {
15567       _bfd_error_handler
15568         (_("%pB: endianness incompatible with that of the selected emulation"),
15569          ibfd);
15570       return FALSE;
15571     }
15572
15573   if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
15574     return TRUE;
15575
15576   in_tdata = mips_elf_tdata (ibfd);
15577   out_tdata = mips_elf_tdata (obfd);
15578
15579   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
15580     {
15581       _bfd_error_handler
15582         (_("%pB: ABI is incompatible with that of the selected emulation"),
15583          ibfd);
15584       return FALSE;
15585     }
15586
15587   /* Check to see if the input BFD actually contains any sections.  If not,
15588      then it has no attributes, and its flags may not have been initialized
15589      either, but it cannot actually cause any incompatibility.  */
15590   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
15591     {
15592       /* Ignore synthetic sections and empty .text, .data and .bss sections
15593          which are automatically generated by gas.  Also ignore fake
15594          (s)common sections, since merely defining a common symbol does
15595          not affect compatibility.  */
15596       if ((sec->flags & SEC_IS_COMMON) == 0
15597           && strcmp (sec->name, ".reginfo")
15598           && strcmp (sec->name, ".mdebug")
15599           && (sec->size != 0
15600               || (strcmp (sec->name, ".text")
15601                   && strcmp (sec->name, ".data")
15602                   && strcmp (sec->name, ".bss"))))
15603         {
15604           null_input_bfd = FALSE;
15605           break;
15606         }
15607     }
15608   if (null_input_bfd)
15609     return TRUE;
15610
15611   /* Populate abiflags using existing information.  */
15612   if (in_tdata->abiflags_valid)
15613     {
15614       obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15615       Elf_Internal_ABIFlags_v0 in_abiflags;
15616       Elf_Internal_ABIFlags_v0 abiflags;
15617
15618       /* Set up the FP ABI attribute from the abiflags if it is not already
15619          set.  */
15620       if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY)
15621         in_attr[Tag_GNU_MIPS_ABI_FP].i = in_tdata->abiflags.fp_abi;
15622
15623       infer_mips_abiflags (ibfd, &abiflags);
15624       in_abiflags = in_tdata->abiflags;
15625
15626       /* It is not possible to infer the correct ISA revision
15627          for R3 or R5 so drop down to R2 for the checks.  */
15628       if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5)
15629         in_abiflags.isa_rev = 2;
15630
15631       if (LEVEL_REV (in_abiflags.isa_level, in_abiflags.isa_rev)
15632           < LEVEL_REV (abiflags.isa_level, abiflags.isa_rev))
15633         _bfd_error_handler
15634           (_("%pB: warning: inconsistent ISA between e_flags and "
15635              ".MIPS.abiflags"), ibfd);
15636       if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
15637           && in_abiflags.fp_abi != abiflags.fp_abi)
15638         _bfd_error_handler
15639           (_("%pB: warning: inconsistent FP ABI between .gnu.attributes and "
15640              ".MIPS.abiflags"), ibfd);
15641       if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
15642         _bfd_error_handler
15643           (_("%pB: warning: inconsistent ASEs between e_flags and "
15644              ".MIPS.abiflags"), ibfd);
15645       /* The isa_ext is allowed to be an extension of what can be inferred
15646          from e_flags.  */
15647       if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags.isa_ext),
15648                                 bfd_mips_isa_ext_mach (in_abiflags.isa_ext)))
15649         _bfd_error_handler
15650           (_("%pB: warning: inconsistent ISA extensions between e_flags and "
15651              ".MIPS.abiflags"), ibfd);
15652       if (in_abiflags.flags2 != 0)
15653         _bfd_error_handler
15654           (_("%pB: warning: unexpected flag in the flags2 field of "
15655              ".MIPS.abiflags (0x%lx)"), ibfd,
15656            in_abiflags.flags2);
15657     }
15658   else
15659     {
15660       infer_mips_abiflags (ibfd, &in_tdata->abiflags);
15661       in_tdata->abiflags_valid = TRUE;
15662     }
15663
15664   if (!out_tdata->abiflags_valid)
15665     {
15666       /* Copy input abiflags if output abiflags are not already valid.  */
15667       out_tdata->abiflags = in_tdata->abiflags;
15668       out_tdata->abiflags_valid = TRUE;
15669     }
15670
15671   if (! elf_flags_init (obfd))
15672     {
15673       elf_flags_init (obfd) = TRUE;
15674       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
15675       elf_elfheader (obfd)->e_ident[EI_CLASS]
15676         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
15677
15678       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
15679           && (bfd_get_arch_info (obfd)->the_default
15680               || mips_mach_extends_p (bfd_get_mach (obfd),
15681                                       bfd_get_mach (ibfd))))
15682         {
15683           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
15684                                    bfd_get_mach (ibfd)))
15685             return FALSE;
15686
15687           /* Update the ABI flags isa_level, isa_rev and isa_ext fields.  */
15688           update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15689         }
15690
15691       ok = TRUE;
15692     }
15693   else
15694     ok = mips_elf_merge_obj_e_flags (ibfd, info);
15695
15696   ok = mips_elf_merge_obj_attributes (ibfd, info) && ok;
15697
15698   ok = mips_elf_merge_obj_abiflags (ibfd, obfd) && ok;
15699
15700   if (!ok)
15701     {
15702       bfd_set_error (bfd_error_bad_value);
15703       return FALSE;
15704     }
15705
15706   return TRUE;
15707 }
15708
15709 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
15710
15711 bfd_boolean
15712 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
15713 {
15714   BFD_ASSERT (!elf_flags_init (abfd)
15715               || elf_elfheader (abfd)->e_flags == flags);
15716
15717   elf_elfheader (abfd)->e_flags = flags;
15718   elf_flags_init (abfd) = TRUE;
15719   return TRUE;
15720 }
15721
15722 char *
15723 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
15724 {
15725   switch (dtag)
15726     {
15727     default: return "";
15728     case DT_MIPS_RLD_VERSION:
15729       return "MIPS_RLD_VERSION";
15730     case DT_MIPS_TIME_STAMP:
15731       return "MIPS_TIME_STAMP";
15732     case DT_MIPS_ICHECKSUM:
15733       return "MIPS_ICHECKSUM";
15734     case DT_MIPS_IVERSION:
15735       return "MIPS_IVERSION";
15736     case DT_MIPS_FLAGS:
15737       return "MIPS_FLAGS";
15738     case DT_MIPS_BASE_ADDRESS:
15739       return "MIPS_BASE_ADDRESS";
15740     case DT_MIPS_MSYM:
15741       return "MIPS_MSYM";
15742     case DT_MIPS_CONFLICT:
15743       return "MIPS_CONFLICT";
15744     case DT_MIPS_LIBLIST:
15745       return "MIPS_LIBLIST";
15746     case DT_MIPS_LOCAL_GOTNO:
15747       return "MIPS_LOCAL_GOTNO";
15748     case DT_MIPS_CONFLICTNO:
15749       return "MIPS_CONFLICTNO";
15750     case DT_MIPS_LIBLISTNO:
15751       return "MIPS_LIBLISTNO";
15752     case DT_MIPS_SYMTABNO:
15753       return "MIPS_SYMTABNO";
15754     case DT_MIPS_UNREFEXTNO:
15755       return "MIPS_UNREFEXTNO";
15756     case DT_MIPS_GOTSYM:
15757       return "MIPS_GOTSYM";
15758     case DT_MIPS_HIPAGENO:
15759       return "MIPS_HIPAGENO";
15760     case DT_MIPS_RLD_MAP:
15761       return "MIPS_RLD_MAP";
15762     case DT_MIPS_RLD_MAP_REL:
15763       return "MIPS_RLD_MAP_REL";
15764     case DT_MIPS_DELTA_CLASS:
15765       return "MIPS_DELTA_CLASS";
15766     case DT_MIPS_DELTA_CLASS_NO:
15767       return "MIPS_DELTA_CLASS_NO";
15768     case DT_MIPS_DELTA_INSTANCE:
15769       return "MIPS_DELTA_INSTANCE";
15770     case DT_MIPS_DELTA_INSTANCE_NO:
15771       return "MIPS_DELTA_INSTANCE_NO";
15772     case DT_MIPS_DELTA_RELOC:
15773       return "MIPS_DELTA_RELOC";
15774     case DT_MIPS_DELTA_RELOC_NO:
15775       return "MIPS_DELTA_RELOC_NO";
15776     case DT_MIPS_DELTA_SYM:
15777       return "MIPS_DELTA_SYM";
15778     case DT_MIPS_DELTA_SYM_NO:
15779       return "MIPS_DELTA_SYM_NO";
15780     case DT_MIPS_DELTA_CLASSSYM:
15781       return "MIPS_DELTA_CLASSSYM";
15782     case DT_MIPS_DELTA_CLASSSYM_NO:
15783       return "MIPS_DELTA_CLASSSYM_NO";
15784     case DT_MIPS_CXX_FLAGS:
15785       return "MIPS_CXX_FLAGS";
15786     case DT_MIPS_PIXIE_INIT:
15787       return "MIPS_PIXIE_INIT";
15788     case DT_MIPS_SYMBOL_LIB:
15789       return "MIPS_SYMBOL_LIB";
15790     case DT_MIPS_LOCALPAGE_GOTIDX:
15791       return "MIPS_LOCALPAGE_GOTIDX";
15792     case DT_MIPS_LOCAL_GOTIDX:
15793       return "MIPS_LOCAL_GOTIDX";
15794     case DT_MIPS_HIDDEN_GOTIDX:
15795       return "MIPS_HIDDEN_GOTIDX";
15796     case DT_MIPS_PROTECTED_GOTIDX:
15797       return "MIPS_PROTECTED_GOT_IDX";
15798     case DT_MIPS_OPTIONS:
15799       return "MIPS_OPTIONS";
15800     case DT_MIPS_INTERFACE:
15801       return "MIPS_INTERFACE";
15802     case DT_MIPS_DYNSTR_ALIGN:
15803       return "DT_MIPS_DYNSTR_ALIGN";
15804     case DT_MIPS_INTERFACE_SIZE:
15805       return "DT_MIPS_INTERFACE_SIZE";
15806     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
15807       return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15808     case DT_MIPS_PERF_SUFFIX:
15809       return "DT_MIPS_PERF_SUFFIX";
15810     case DT_MIPS_COMPACT_SIZE:
15811       return "DT_MIPS_COMPACT_SIZE";
15812     case DT_MIPS_GP_VALUE:
15813       return "DT_MIPS_GP_VALUE";
15814     case DT_MIPS_AUX_DYNAMIC:
15815       return "DT_MIPS_AUX_DYNAMIC";
15816     case DT_MIPS_PLTGOT:
15817       return "DT_MIPS_PLTGOT";
15818     case DT_MIPS_RWPLT:
15819       return "DT_MIPS_RWPLT";
15820     }
15821 }
15822
15823 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15824    not known.  */
15825
15826 const char *
15827 _bfd_mips_fp_abi_string (int fp)
15828 {
15829   switch (fp)
15830     {
15831       /* These strings aren't translated because they're simply
15832          option lists.  */
15833     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15834       return "-mdouble-float";
15835
15836     case Val_GNU_MIPS_ABI_FP_SINGLE:
15837       return "-msingle-float";
15838
15839     case Val_GNU_MIPS_ABI_FP_SOFT:
15840       return "-msoft-float";
15841
15842     case Val_GNU_MIPS_ABI_FP_OLD_64:
15843       return _("-mips32r2 -mfp64 (12 callee-saved)");
15844
15845     case Val_GNU_MIPS_ABI_FP_XX:
15846       return "-mfpxx";
15847
15848     case Val_GNU_MIPS_ABI_FP_64:
15849       return "-mgp32 -mfp64";
15850
15851     case Val_GNU_MIPS_ABI_FP_64A:
15852       return "-mgp32 -mfp64 -mno-odd-spreg";
15853
15854     default:
15855       return 0;
15856     }
15857 }
15858
15859 static void
15860 print_mips_ases (FILE *file, unsigned int mask)
15861 {
15862   if (mask & AFL_ASE_DSP)
15863     fputs ("\n\tDSP ASE", file);
15864   if (mask & AFL_ASE_DSPR2)
15865     fputs ("\n\tDSP R2 ASE", file);
15866   if (mask & AFL_ASE_DSPR3)
15867     fputs ("\n\tDSP R3 ASE", file);
15868   if (mask & AFL_ASE_EVA)
15869     fputs ("\n\tEnhanced VA Scheme", file);
15870   if (mask & AFL_ASE_MCU)
15871     fputs ("\n\tMCU (MicroController) ASE", file);
15872   if (mask & AFL_ASE_MDMX)
15873     fputs ("\n\tMDMX ASE", file);
15874   if (mask & AFL_ASE_MIPS3D)
15875     fputs ("\n\tMIPS-3D ASE", file);
15876   if (mask & AFL_ASE_MT)
15877     fputs ("\n\tMT ASE", file);
15878   if (mask & AFL_ASE_SMARTMIPS)
15879     fputs ("\n\tSmartMIPS ASE", file);
15880   if (mask & AFL_ASE_VIRT)
15881     fputs ("\n\tVZ ASE", file);
15882   if (mask & AFL_ASE_MSA)
15883     fputs ("\n\tMSA ASE", file);
15884   if (mask & AFL_ASE_MIPS16)
15885     fputs ("\n\tMIPS16 ASE", file);
15886   if (mask & AFL_ASE_MICROMIPS)
15887     fputs ("\n\tMICROMIPS ASE", file);
15888   if (mask & AFL_ASE_XPA)
15889     fputs ("\n\tXPA ASE", file);
15890   if (mask & AFL_ASE_MIPS16E2)
15891     fputs ("\n\tMIPS16e2 ASE", file);
15892   if (mask & AFL_ASE_CRC)
15893     fputs ("\n\tCRC ASE", file);
15894   if (mask & AFL_ASE_GINV)
15895     fputs ("\n\tGINV ASE", file);
15896   if (mask & AFL_ASE_LOONGSON_MMI)
15897     fputs ("\n\tLoongson MMI ASE", file);
15898   if (mask & AFL_ASE_LOONGSON_CAM)
15899     fputs ("\n\tLoongson CAM ASE", file);
15900   if (mask & AFL_ASE_LOONGSON_EXT)
15901     fputs ("\n\tLoongson EXT ASE", file);
15902   if (mask & AFL_ASE_LOONGSON_EXT2)
15903     fputs ("\n\tLoongson EXT2 ASE", file);
15904   if (mask == 0)
15905     fprintf (file, "\n\t%s", _("None"));
15906   else if ((mask & ~AFL_ASE_MASK) != 0)
15907     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15908 }
15909
15910 static void
15911 print_mips_isa_ext (FILE *file, unsigned int isa_ext)
15912 {
15913   switch (isa_ext)
15914     {
15915     case 0:
15916       fputs (_("None"), file);
15917       break;
15918     case AFL_EXT_XLR:
15919       fputs ("RMI XLR", file);
15920       break;
15921     case AFL_EXT_OCTEON3:
15922       fputs ("Cavium Networks Octeon3", file);
15923       break;
15924     case AFL_EXT_OCTEON2:
15925       fputs ("Cavium Networks Octeon2", file);
15926       break;
15927     case AFL_EXT_OCTEONP:
15928       fputs ("Cavium Networks OcteonP", file);
15929       break;
15930     case AFL_EXT_OCTEON:
15931       fputs ("Cavium Networks Octeon", file);
15932       break;
15933     case AFL_EXT_5900:
15934       fputs ("Toshiba R5900", file);
15935       break;
15936     case AFL_EXT_4650:
15937       fputs ("MIPS R4650", file);
15938       break;
15939     case AFL_EXT_4010:
15940       fputs ("LSI R4010", file);
15941       break;
15942     case AFL_EXT_4100:
15943       fputs ("NEC VR4100", file);
15944       break;
15945     case AFL_EXT_3900:
15946       fputs ("Toshiba R3900", file);
15947       break;
15948     case AFL_EXT_10000:
15949       fputs ("MIPS R10000", file);
15950       break;
15951     case AFL_EXT_SB1:
15952       fputs ("Broadcom SB-1", file);
15953       break;
15954     case AFL_EXT_4111:
15955       fputs ("NEC VR4111/VR4181", file);
15956       break;
15957     case AFL_EXT_4120:
15958       fputs ("NEC VR4120", file);
15959       break;
15960     case AFL_EXT_5400:
15961       fputs ("NEC VR5400", file);
15962       break;
15963     case AFL_EXT_5500:
15964       fputs ("NEC VR5500", file);
15965       break;
15966     case AFL_EXT_LOONGSON_2E:
15967       fputs ("ST Microelectronics Loongson 2E", file);
15968       break;
15969     case AFL_EXT_LOONGSON_2F:
15970       fputs ("ST Microelectronics Loongson 2F", file);
15971       break;
15972     case AFL_EXT_INTERAPTIV_MR2:
15973       fputs ("Imagination interAptiv MR2", file);
15974       break;
15975     default:
15976       fprintf (file, "%s (%d)", _("Unknown"), isa_ext);
15977       break;
15978     }
15979 }
15980
15981 static void
15982 print_mips_fp_abi_value (FILE *file, int val)
15983 {
15984   switch (val)
15985     {
15986     case Val_GNU_MIPS_ABI_FP_ANY:
15987       fprintf (file, _("Hard or soft float\n"));
15988       break;
15989     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15990       fprintf (file, _("Hard float (double precision)\n"));
15991       break;
15992     case Val_GNU_MIPS_ABI_FP_SINGLE:
15993       fprintf (file, _("Hard float (single precision)\n"));
15994       break;
15995     case Val_GNU_MIPS_ABI_FP_SOFT:
15996       fprintf (file, _("Soft float\n"));
15997       break;
15998     case Val_GNU_MIPS_ABI_FP_OLD_64:
15999       fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16000       break;
16001     case Val_GNU_MIPS_ABI_FP_XX:
16002       fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n"));
16003       break;
16004     case Val_GNU_MIPS_ABI_FP_64:
16005       fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
16006       break;
16007     case Val_GNU_MIPS_ABI_FP_64A:
16008       fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16009       break;
16010     default:
16011       fprintf (file, "??? (%d)\n", val);
16012       break;
16013     }
16014 }
16015
16016 static int
16017 get_mips_reg_size (int reg_size)
16018 {
16019   return (reg_size == AFL_REG_NONE) ? 0
16020          : (reg_size == AFL_REG_32) ? 32
16021          : (reg_size == AFL_REG_64) ? 64
16022          : (reg_size == AFL_REG_128) ? 128
16023          : -1;
16024 }
16025
16026 bfd_boolean
16027 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
16028 {
16029   FILE *file = ptr;
16030
16031   BFD_ASSERT (abfd != NULL && ptr != NULL);
16032
16033   /* Print normal ELF private data.  */
16034   _bfd_elf_print_private_bfd_data (abfd, ptr);
16035
16036   /* xgettext:c-format */
16037   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
16038
16039   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
16040     fprintf (file, _(" [abi=O32]"));
16041   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
16042     fprintf (file, _(" [abi=O64]"));
16043   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
16044     fprintf (file, _(" [abi=EABI32]"));
16045   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
16046     fprintf (file, _(" [abi=EABI64]"));
16047   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
16048     fprintf (file, _(" [abi unknown]"));
16049   else if (ABI_N32_P (abfd))
16050     fprintf (file, _(" [abi=N32]"));
16051   else if (ABI_64_P (abfd))
16052     fprintf (file, _(" [abi=64]"));
16053   else
16054     fprintf (file, _(" [no abi set]"));
16055
16056   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
16057     fprintf (file, " [mips1]");
16058   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
16059     fprintf (file, " [mips2]");
16060   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
16061     fprintf (file, " [mips3]");
16062   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
16063     fprintf (file, " [mips4]");
16064   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
16065     fprintf (file, " [mips5]");
16066   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
16067     fprintf (file, " [mips32]");
16068   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
16069     fprintf (file, " [mips64]");
16070   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
16071     fprintf (file, " [mips32r2]");
16072   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
16073     fprintf (file, " [mips64r2]");
16074   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6)
16075     fprintf (file, " [mips32r6]");
16076   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
16077     fprintf (file, " [mips64r6]");
16078   else
16079     fprintf (file, _(" [unknown ISA]"));
16080
16081   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
16082     fprintf (file, " [mdmx]");
16083
16084   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
16085     fprintf (file, " [mips16]");
16086
16087   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
16088     fprintf (file, " [micromips]");
16089
16090   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008)
16091     fprintf (file, " [nan2008]");
16092
16093   if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64)
16094     fprintf (file, " [old fp64]");
16095
16096   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
16097     fprintf (file, " [32bitmode]");
16098   else
16099     fprintf (file, _(" [not 32bitmode]"));
16100
16101   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
16102     fprintf (file, " [noreorder]");
16103
16104   if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
16105     fprintf (file, " [PIC]");
16106
16107   if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
16108     fprintf (file, " [CPIC]");
16109
16110   if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
16111     fprintf (file, " [XGOT]");
16112
16113   if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
16114     fprintf (file, " [UCODE]");
16115
16116   fputc ('\n', file);
16117
16118   if (mips_elf_tdata (abfd)->abiflags_valid)
16119     {
16120       Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags;
16121       fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version);
16122       fprintf (file, "\nISA: MIPS%d", abiflags->isa_level);
16123       if (abiflags->isa_rev > 1)
16124         fprintf (file, "r%d", abiflags->isa_rev);
16125       fprintf (file, "\nGPR size: %d",
16126                get_mips_reg_size (abiflags->gpr_size));
16127       fprintf (file, "\nCPR1 size: %d",
16128                get_mips_reg_size (abiflags->cpr1_size));
16129       fprintf (file, "\nCPR2 size: %d",
16130                get_mips_reg_size (abiflags->cpr2_size));
16131       fputs ("\nFP ABI: ", file);
16132       print_mips_fp_abi_value (file, abiflags->fp_abi);
16133       fputs ("ISA Extension: ", file);
16134       print_mips_isa_ext (file, abiflags->isa_ext);
16135       fputs ("\nASEs:", file);
16136       print_mips_ases (file, abiflags->ases);
16137       fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1);
16138       fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2);
16139       fputc ('\n', file);
16140     }
16141
16142   return TRUE;
16143 }
16144
16145 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
16146 {
16147   { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16148   { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16149   { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
16150   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16151   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16152   { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
16153   { NULL,                     0,  0, 0,              0 }
16154 };
16155
16156 /* Merge non visibility st_other attributes.  Ensure that the
16157    STO_OPTIONAL flag is copied into h->other, even if this is not a
16158    definiton of the symbol.  */
16159 void
16160 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
16161                                       const Elf_Internal_Sym *isym,
16162                                       bfd_boolean definition,
16163                                       bfd_boolean dynamic ATTRIBUTE_UNUSED)
16164 {
16165   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
16166     {
16167       unsigned char other;
16168
16169       other = (definition ? isym->st_other : h->other);
16170       other &= ~ELF_ST_VISIBILITY (-1);
16171       h->other = other | ELF_ST_VISIBILITY (h->other);
16172     }
16173
16174   if (!definition
16175       && ELF_MIPS_IS_OPTIONAL (isym->st_other))
16176     h->other |= STO_OPTIONAL;
16177 }
16178
16179 /* Decide whether an undefined symbol is special and can be ignored.
16180    This is the case for OPTIONAL symbols on IRIX.  */
16181 bfd_boolean
16182 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
16183 {
16184   return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
16185 }
16186
16187 bfd_boolean
16188 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
16189 {
16190   return (sym->st_shndx == SHN_COMMON
16191           || sym->st_shndx == SHN_MIPS_ACOMMON
16192           || sym->st_shndx == SHN_MIPS_SCOMMON);
16193 }
16194
16195 /* Return address for Ith PLT stub in section PLT, for relocation REL
16196    or (bfd_vma) -1 if it should not be included.  */
16197
16198 bfd_vma
16199 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
16200                            const arelent *rel ATTRIBUTE_UNUSED)
16201 {
16202   return (plt->vma
16203           + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
16204           + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
16205 }
16206
16207 /* Build a table of synthetic symbols to represent the PLT.  As with MIPS16
16208    and microMIPS PLT slots we may have a many-to-one mapping between .plt
16209    and .got.plt and also the slots may be of a different size each we walk
16210    the PLT manually fetching instructions and matching them against known
16211    patterns.  To make things easier standard MIPS slots, if any, always come
16212    first.  As we don't create proper ELF symbols we use the UDATA.I member
16213    of ASYMBOL to carry ISA annotation.  The encoding used is the same as
16214    with the ST_OTHER member of the ELF symbol.  */
16215
16216 long
16217 _bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
16218                                     long symcount ATTRIBUTE_UNUSED,
16219                                     asymbol **syms ATTRIBUTE_UNUSED,
16220                                     long dynsymcount, asymbol **dynsyms,
16221                                     asymbol **ret)
16222 {
16223   static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_";
16224   static const char microsuffix[] = "@micromipsplt";
16225   static const char m16suffix[] = "@mips16plt";
16226   static const char mipssuffix[] = "@plt";
16227
16228   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
16229   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
16230   bfd_boolean micromips_p = MICROMIPS_P (abfd);
16231   Elf_Internal_Shdr *hdr;
16232   bfd_byte *plt_data;
16233   bfd_vma plt_offset;
16234   unsigned int other;
16235   bfd_vma entry_size;
16236   bfd_vma plt0_size;
16237   asection *relplt;
16238   bfd_vma opcode;
16239   asection *plt;
16240   asymbol *send;
16241   size_t size;
16242   char *names;
16243   long counti;
16244   arelent *p;
16245   asymbol *s;
16246   char *nend;
16247   long count;
16248   long pi;
16249   long i;
16250   long n;
16251
16252   *ret = NULL;
16253
16254   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0)
16255     return 0;
16256
16257   relplt = bfd_get_section_by_name (abfd, ".rel.plt");
16258   if (relplt == NULL)
16259     return 0;
16260
16261   hdr = &elf_section_data (relplt)->this_hdr;
16262   if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL)
16263     return 0;
16264
16265   plt = bfd_get_section_by_name (abfd, ".plt");
16266   if (plt == NULL)
16267     return 0;
16268
16269   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
16270   if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
16271     return -1;
16272   p = relplt->relocation;
16273
16274   /* Calculating the exact amount of space required for symbols would
16275      require two passes over the PLT, so just pessimise assuming two
16276      PLT slots per relocation.  */
16277   count = relplt->size / hdr->sh_entsize;
16278   counti = count * bed->s->int_rels_per_ext_rel;
16279   size = 2 * count * sizeof (asymbol);
16280   size += count * (sizeof (mipssuffix) +
16281                    (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix)));
16282   for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel)
16283     size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name);
16284
16285   /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too.  */
16286   size += sizeof (asymbol) + sizeof (pltname);
16287
16288   if (!bfd_malloc_and_get_section (abfd, plt, &plt_data))
16289     return -1;
16290
16291   if (plt->size < 16)
16292     return -1;
16293
16294   s = *ret = bfd_malloc (size);
16295   if (s == NULL)
16296     return -1;
16297   send = s + 2 * count + 1;
16298
16299   names = (char *) send;
16300   nend = (char *) s + size;
16301   n = 0;
16302
16303   opcode = bfd_get_micromips_32 (abfd, plt_data + 12);
16304   if (opcode == 0x3302fffe)
16305     {
16306       if (!micromips_p)
16307         return -1;
16308       plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
16309       other = STO_MICROMIPS;
16310     }
16311   else if (opcode == 0x0398c1d0)
16312     {
16313       if (!micromips_p)
16314         return -1;
16315       plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
16316       other = STO_MICROMIPS;
16317     }
16318   else
16319     {
16320       plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
16321       other = 0;
16322     }
16323
16324   s->the_bfd = abfd;
16325   s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL;
16326   s->section = plt;
16327   s->value = 0;
16328   s->name = names;
16329   s->udata.i = other;
16330   memcpy (names, pltname, sizeof (pltname));
16331   names += sizeof (pltname);
16332   ++s, ++n;
16333
16334   pi = 0;
16335   for (plt_offset = plt0_size;
16336        plt_offset + 8 <= plt->size && s < send;
16337        plt_offset += entry_size)
16338     {
16339       bfd_vma gotplt_addr;
16340       const char *suffix;
16341       bfd_vma gotplt_hi;
16342       bfd_vma gotplt_lo;
16343       size_t suffixlen;
16344
16345       opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4);
16346
16347       /* Check if the second word matches the expected MIPS16 instruction.  */
16348       if (opcode == 0x651aeb00)
16349         {
16350           if (micromips_p)
16351             return -1;
16352           /* Truncated table???  */
16353           if (plt_offset + 16 > plt->size)
16354             break;
16355           gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12);
16356           entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
16357           suffixlen = sizeof (m16suffix);
16358           suffix = m16suffix;
16359           other = STO_MIPS16;
16360         }
16361       /* Likewise the expected microMIPS instruction (no insn32 mode).  */
16362       else if (opcode == 0xff220000)
16363         {
16364           if (!micromips_p)
16365             return -1;
16366           gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f;
16367           gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16368           gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18;
16369           gotplt_lo <<= 2;
16370           gotplt_addr = gotplt_hi + gotplt_lo;
16371           gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3;
16372           entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
16373           suffixlen = sizeof (microsuffix);
16374           suffix = microsuffix;
16375           other = STO_MICROMIPS;
16376         }
16377       /* Likewise the expected microMIPS instruction (insn32 mode).  */
16378       else if ((opcode & 0xffff0000) == 0xff2f0000)
16379         {
16380           gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16381           gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff;
16382           gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16383           gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16384           gotplt_addr = gotplt_hi + gotplt_lo;
16385           entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
16386           suffixlen = sizeof (microsuffix);
16387           suffix = microsuffix;
16388           other = STO_MICROMIPS;
16389         }
16390       /* Otherwise assume standard MIPS code.  */
16391       else
16392         {
16393           gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff;
16394           gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff;
16395           gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16396           gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16397           gotplt_addr = gotplt_hi + gotplt_lo;
16398           entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
16399           suffixlen = sizeof (mipssuffix);
16400           suffix = mipssuffix;
16401           other = 0;
16402         }
16403       /* Truncated table???  */
16404       if (plt_offset + entry_size > plt->size)
16405         break;
16406
16407       for (i = 0;
16408            i < count && p[pi].address != gotplt_addr;
16409            i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti);
16410
16411       if (i < count)
16412         {
16413           size_t namelen;
16414           size_t len;
16415
16416           *s = **p[pi].sym_ptr_ptr;
16417           /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
16418              we are defining a symbol, ensure one of them is set.  */
16419           if ((s->flags & BSF_LOCAL) == 0)
16420             s->flags |= BSF_GLOBAL;
16421           s->flags |= BSF_SYNTHETIC;
16422           s->section = plt;
16423           s->value = plt_offset;
16424           s->name = names;
16425           s->udata.i = other;
16426
16427           len = strlen ((*p[pi].sym_ptr_ptr)->name);
16428           namelen = len + suffixlen;
16429           if (names + namelen > nend)
16430             break;
16431
16432           memcpy (names, (*p[pi].sym_ptr_ptr)->name, len);
16433           names += len;
16434           memcpy (names, suffix, suffixlen);
16435           names += suffixlen;
16436
16437           ++s, ++n;
16438           pi = (pi + bed->s->int_rels_per_ext_rel) % counti;
16439         }
16440     }
16441
16442   free (plt_data);
16443
16444   return n;
16445 }
16446
16447 /* Return the ABI flags associated with ABFD if available.  */
16448
16449 Elf_Internal_ABIFlags_v0 *
16450 bfd_mips_elf_get_abiflags (bfd *abfd)
16451 {
16452   struct mips_elf_obj_tdata *tdata = mips_elf_tdata (abfd);
16453
16454   return tdata->abiflags_valid ? &tdata->abiflags : NULL;
16455 }
16456
16457 /* MIPS libc ABI versions, used with the EI_ABIVERSION ELF file header
16458    field.  Taken from `libc-abis.h' generated at GNU libc build time.
16459    Using a MIPS_ prefix as other libc targets use different values.  */
16460 enum
16461 {
16462   MIPS_LIBC_ABI_DEFAULT = 0,
16463   MIPS_LIBC_ABI_MIPS_PLT,
16464   MIPS_LIBC_ABI_UNIQUE,
16465   MIPS_LIBC_ABI_MIPS_O32_FP64,
16466   MIPS_LIBC_ABI_ABSOLUTE,
16467   MIPS_LIBC_ABI_MAX
16468 };
16469
16470 void
16471 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
16472 {
16473   struct mips_elf_link_hash_table *htab = NULL;
16474   Elf_Internal_Ehdr *i_ehdrp;
16475
16476   i_ehdrp = elf_elfheader (abfd);
16477   if (link_info)
16478     {
16479       htab = mips_elf_hash_table (link_info);
16480       BFD_ASSERT (htab != NULL);
16481     }
16482
16483   if (htab != NULL && htab->use_plts_and_copy_relocs && !htab->is_vxworks)
16484     i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_MIPS_PLT;
16485
16486   if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64
16487       || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A)
16488     i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_MIPS_O32_FP64;
16489
16490   /* Mark that we need support for absolute symbols in the dynamic loader.  */
16491   if (htab != NULL && htab->use_absolute_zero && htab->gnu_target)
16492     i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_ABSOLUTE;
16493
16494   _bfd_elf_post_process_headers (abfd, link_info);
16495 }
16496
16497 int
16498 _bfd_mips_elf_compact_eh_encoding
16499   (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16500 {
16501   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
16502 }
16503
16504 /* Return the opcode for can't unwind.  */
16505
16506 int
16507 _bfd_mips_elf_cant_unwind_opcode
16508   (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16509 {
16510   return COMPACT_EH_CANT_UNWIND_OPCODE;
16511 }