MIPS/opcodes: Also set disassembler's ASE flags from ELF structures
[external/binutils.git] / bfd / elfxx-mips.c
1 /* MIPS-specific support for ELF
2    Copyright (C) 1993-2016 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   long 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   long max_unref_got_dynindx;
318   /* The greatest dynamic symbol table index not corresponding to a
319      symbol without a GOT entry.  */
320   long max_non_got_dynindx;
321 };
322
323 /* We make up to two PLT entries if needed, one for standard MIPS code
324    and one for compressed code, either a MIPS16 or microMIPS one.  We
325    keep a separate record of traditional lazy-binding stubs, for easier
326    processing.  */
327
328 struct plt_entry
329 {
330   /* Traditional SVR4 stub offset, or -1 if none.  */
331   bfd_vma stub_offset;
332
333   /* Standard PLT entry offset, or -1 if none.  */
334   bfd_vma mips_offset;
335
336   /* Compressed PLT entry offset, or -1 if none.  */
337   bfd_vma comp_offset;
338
339   /* The corresponding .got.plt index, or -1 if none.  */
340   bfd_vma gotplt_index;
341
342   /* Whether we need a standard PLT entry.  */
343   unsigned int need_mips : 1;
344
345   /* Whether we need a compressed PLT entry.  */
346   unsigned int need_comp : 1;
347 };
348
349 /* The MIPS ELF linker needs additional information for each symbol in
350    the global hash table.  */
351
352 struct mips_elf_link_hash_entry
353 {
354   struct elf_link_hash_entry root;
355
356   /* External symbol information.  */
357   EXTR esym;
358
359   /* The la25 stub we have created for ths symbol, if any.  */
360   struct mips_elf_la25_stub *la25_stub;
361
362   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
363      this symbol.  */
364   unsigned int possibly_dynamic_relocs;
365
366   /* If there is a stub that 32 bit functions should use to call this
367      16 bit function, this points to the section containing the stub.  */
368   asection *fn_stub;
369
370   /* If there is a stub that 16 bit functions should use to call this
371      32 bit function, this points to the section containing the stub.  */
372   asection *call_stub;
373
374   /* This is like the call_stub field, but it is used if the function
375      being called returns a floating point value.  */
376   asection *call_fp_stub;
377
378   /* The highest GGA_* value that satisfies all references to this symbol.  */
379   unsigned int global_got_area : 2;
380
381   /* True if all GOT relocations against this symbol are for calls.  This is
382      a looser condition than no_fn_stub below, because there may be other
383      non-call non-GOT relocations against the symbol.  */
384   unsigned int got_only_for_calls : 1;
385
386   /* True if one of the relocations described by possibly_dynamic_relocs
387      is against a readonly section.  */
388   unsigned int readonly_reloc : 1;
389
390   /* True if there is a relocation against this symbol that must be
391      resolved by the static linker (in other words, if the relocation
392      cannot possibly be made dynamic).  */
393   unsigned int has_static_relocs : 1;
394
395   /* True if we must not create a .MIPS.stubs entry for this symbol.
396      This is set, for example, if there are relocations related to
397      taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
398      See "MIPS ABI Supplement, 3rd Edition", p. 4-20.  */
399   unsigned int no_fn_stub : 1;
400
401   /* Whether we need the fn_stub; this is true if this symbol appears
402      in any relocs other than a 16 bit call.  */
403   unsigned int need_fn_stub : 1;
404
405   /* True if this symbol is referenced by branch relocations from
406      any non-PIC input file.  This is used to determine whether an
407      la25 stub is required.  */
408   unsigned int has_nonpic_branches : 1;
409
410   /* Does this symbol need a traditional MIPS lazy-binding stub
411      (as opposed to a PLT entry)?  */
412   unsigned int needs_lazy_stub : 1;
413
414   /* Does this symbol resolve to a PLT entry?  */
415   unsigned int use_plt_entry : 1;
416 };
417
418 /* MIPS ELF linker hash table.  */
419
420 struct mips_elf_link_hash_table
421 {
422   struct elf_link_hash_table root;
423
424   /* The number of .rtproc entries.  */
425   bfd_size_type procedure_count;
426
427   /* The size of the .compact_rel section (if SGI_COMPAT).  */
428   bfd_size_type compact_rel_size;
429
430   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
431      is set to the address of __rld_obj_head as in IRIX5 and IRIX6.  */
432   bfd_boolean use_rld_obj_head;
433
434   /* The  __rld_map or __rld_obj_head symbol. */
435   struct elf_link_hash_entry *rld_symbol;
436
437   /* This is set if we see any mips16 stub sections.  */
438   bfd_boolean mips16_stubs_seen;
439
440   /* True if we can generate copy relocs and PLTs.  */
441   bfd_boolean use_plts_and_copy_relocs;
442
443   /* True if we can only use 32-bit microMIPS instructions.  */
444   bfd_boolean insn32;
445
446   /* True if we're generating code for VxWorks.  */
447   bfd_boolean is_vxworks;
448
449   /* True if we already reported the small-data section overflow.  */
450   bfd_boolean small_data_overflow_reported;
451
452   /* Shortcuts to some dynamic sections, or NULL if they are not
453      being used.  */
454   asection *srelbss;
455   asection *sdynbss;
456   asection *srelplt2;
457   asection *sstubs;
458
459   /* The master GOT information.  */
460   struct mips_got_info *got_info;
461
462   /* The global symbol in the GOT with the lowest index in the dynamic
463      symbol table.  */
464   struct elf_link_hash_entry *global_gotsym;
465
466   /* The size of the PLT header in bytes.  */
467   bfd_vma plt_header_size;
468
469   /* The size of a standard PLT entry in bytes.  */
470   bfd_vma plt_mips_entry_size;
471
472   /* The size of a compressed PLT entry in bytes.  */
473   bfd_vma plt_comp_entry_size;
474
475   /* The offset of the next standard PLT entry to create.  */
476   bfd_vma plt_mips_offset;
477
478   /* The offset of the next compressed PLT entry to create.  */
479   bfd_vma plt_comp_offset;
480
481   /* The index of the next .got.plt entry to create.  */
482   bfd_vma plt_got_index;
483
484   /* The number of functions that need a lazy-binding stub.  */
485   bfd_vma lazy_stub_count;
486
487   /* The size of a function stub entry in bytes.  */
488   bfd_vma function_stub_size;
489
490   /* The number of reserved entries at the beginning of the GOT.  */
491   unsigned int reserved_gotno;
492
493   /* The section used for mips_elf_la25_stub trampolines.
494      See the comment above that structure for details.  */
495   asection *strampoline;
496
497   /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
498      pairs.  */
499   htab_t la25_stubs;
500
501   /* A function FN (NAME, IS, OS) that creates a new input section
502      called NAME and links it to output section OS.  If IS is nonnull,
503      the new section should go immediately before it, otherwise it
504      should go at the (current) beginning of OS.
505
506      The function returns the new section on success, otherwise it
507      returns null.  */
508   asection *(*add_stub_section) (const char *, asection *, asection *);
509
510   /* Small local sym cache.  */
511   struct sym_cache sym_cache;
512
513   /* Is the PLT header compressed?  */
514   unsigned int plt_header_is_comp : 1;
515 };
516
517 /* Get the MIPS ELF linker hash table from a link_info structure.  */
518
519 #define mips_elf_hash_table(p) \
520   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
521   == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
522
523 /* A structure used to communicate with htab_traverse callbacks.  */
524 struct mips_htab_traverse_info
525 {
526   /* The usual link-wide information.  */
527   struct bfd_link_info *info;
528   bfd *output_bfd;
529
530   /* Starts off FALSE and is set to TRUE if the link should be aborted.  */
531   bfd_boolean error;
532 };
533
534 /* MIPS ELF private object data.  */
535
536 struct mips_elf_obj_tdata
537 {
538   /* Generic ELF private object data.  */
539   struct elf_obj_tdata root;
540
541   /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output.  */
542   bfd *abi_fp_bfd;
543
544   /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output.  */
545   bfd *abi_msa_bfd;
546
547   /* The abiflags for this object.  */
548   Elf_Internal_ABIFlags_v0 abiflags;
549   bfd_boolean abiflags_valid;
550
551   /* The GOT requirements of input bfds.  */
552   struct mips_got_info *got;
553
554   /* Used by _bfd_mips_elf_find_nearest_line.  The structure could be
555      included directly in this one, but there's no point to wasting
556      the memory just for the infrequently called find_nearest_line.  */
557   struct mips_elf_find_line *find_line_info;
558
559   /* An array of stub sections indexed by symbol number.  */
560   asection **local_stubs;
561   asection **local_call_stubs;
562
563   /* The Irix 5 support uses two virtual sections, which represent
564      text/data symbols defined in dynamic objects.  */
565   asymbol *elf_data_symbol;
566   asymbol *elf_text_symbol;
567   asection *elf_data_section;
568   asection *elf_text_section;
569 };
570
571 /* Get MIPS ELF private object data from BFD's tdata.  */
572
573 #define mips_elf_tdata(bfd) \
574   ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
575
576 #define TLS_RELOC_P(r_type) \
577   (r_type == R_MIPS_TLS_DTPMOD32                \
578    || r_type == R_MIPS_TLS_DTPMOD64             \
579    || r_type == R_MIPS_TLS_DTPREL32             \
580    || r_type == R_MIPS_TLS_DTPREL64             \
581    || r_type == R_MIPS_TLS_GD                   \
582    || r_type == R_MIPS_TLS_LDM                  \
583    || r_type == R_MIPS_TLS_DTPREL_HI16          \
584    || r_type == R_MIPS_TLS_DTPREL_LO16          \
585    || r_type == R_MIPS_TLS_GOTTPREL             \
586    || r_type == R_MIPS_TLS_TPREL32              \
587    || r_type == R_MIPS_TLS_TPREL64              \
588    || r_type == R_MIPS_TLS_TPREL_HI16           \
589    || r_type == R_MIPS_TLS_TPREL_LO16           \
590    || r_type == R_MIPS16_TLS_GD                 \
591    || r_type == R_MIPS16_TLS_LDM                \
592    || r_type == R_MIPS16_TLS_DTPREL_HI16        \
593    || r_type == R_MIPS16_TLS_DTPREL_LO16        \
594    || r_type == R_MIPS16_TLS_GOTTPREL           \
595    || r_type == R_MIPS16_TLS_TPREL_HI16         \
596    || r_type == R_MIPS16_TLS_TPREL_LO16         \
597    || r_type == R_MICROMIPS_TLS_GD              \
598    || r_type == R_MICROMIPS_TLS_LDM             \
599    || r_type == R_MICROMIPS_TLS_DTPREL_HI16     \
600    || r_type == R_MICROMIPS_TLS_DTPREL_LO16     \
601    || r_type == R_MICROMIPS_TLS_GOTTPREL        \
602    || r_type == R_MICROMIPS_TLS_TPREL_HI16      \
603    || r_type == R_MICROMIPS_TLS_TPREL_LO16)
604
605 /* Structure used to pass information to mips_elf_output_extsym.  */
606
607 struct extsym_info
608 {
609   bfd *abfd;
610   struct bfd_link_info *info;
611   struct ecoff_debug_info *debug;
612   const struct ecoff_debug_swap *swap;
613   bfd_boolean failed;
614 };
615
616 /* The names of the runtime procedure table symbols used on IRIX5.  */
617
618 static const char * const mips_elf_dynsym_rtproc_names[] =
619 {
620   "_procedure_table",
621   "_procedure_string_table",
622   "_procedure_table_size",
623   NULL
624 };
625
626 /* These structures are used to generate the .compact_rel section on
627    IRIX5.  */
628
629 typedef struct
630 {
631   unsigned long id1;            /* Always one?  */
632   unsigned long num;            /* Number of compact relocation entries.  */
633   unsigned long id2;            /* Always two?  */
634   unsigned long offset;         /* The file offset of the first relocation.  */
635   unsigned long reserved0;      /* Zero?  */
636   unsigned long reserved1;      /* Zero?  */
637 } Elf32_compact_rel;
638
639 typedef struct
640 {
641   bfd_byte id1[4];
642   bfd_byte num[4];
643   bfd_byte id2[4];
644   bfd_byte offset[4];
645   bfd_byte reserved0[4];
646   bfd_byte reserved1[4];
647 } Elf32_External_compact_rel;
648
649 typedef struct
650 {
651   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
652   unsigned int rtype : 4;       /* Relocation types. See below.  */
653   unsigned int dist2to : 8;
654   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
655   unsigned long konst;          /* KONST field. See below.  */
656   unsigned long vaddr;          /* VADDR to be relocated.  */
657 } Elf32_crinfo;
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 } Elf32_crinfo2;
667
668 typedef struct
669 {
670   bfd_byte info[4];
671   bfd_byte konst[4];
672   bfd_byte vaddr[4];
673 } Elf32_External_crinfo;
674
675 typedef struct
676 {
677   bfd_byte info[4];
678   bfd_byte konst[4];
679 } Elf32_External_crinfo2;
680
681 /* These are the constants used to swap the bitfields in a crinfo.  */
682
683 #define CRINFO_CTYPE (0x1)
684 #define CRINFO_CTYPE_SH (31)
685 #define CRINFO_RTYPE (0xf)
686 #define CRINFO_RTYPE_SH (27)
687 #define CRINFO_DIST2TO (0xff)
688 #define CRINFO_DIST2TO_SH (19)
689 #define CRINFO_RELVADDR (0x7ffff)
690 #define CRINFO_RELVADDR_SH (0)
691
692 /* A compact relocation info has long (3 words) or short (2 words)
693    formats.  A short format doesn't have VADDR field and relvaddr
694    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
695 #define CRF_MIPS_LONG                   1
696 #define CRF_MIPS_SHORT                  0
697
698 /* There are 4 types of compact relocation at least. The value KONST
699    has different meaning for each type:
700
701    (type)               (konst)
702    CT_MIPS_REL32        Address in data
703    CT_MIPS_WORD         Address in word (XXX)
704    CT_MIPS_GPHI_LO      GP - vaddr
705    CT_MIPS_JMPAD        Address to jump
706    */
707
708 #define CRT_MIPS_REL32                  0xa
709 #define CRT_MIPS_WORD                   0xb
710 #define CRT_MIPS_GPHI_LO                0xc
711 #define CRT_MIPS_JMPAD                  0xd
712
713 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
714 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
715 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
716 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
717 \f
718 /* The structure of the runtime procedure descriptor created by the
719    loader for use by the static exception system.  */
720
721 typedef struct runtime_pdr {
722         bfd_vma adr;            /* Memory address of start of procedure.  */
723         long    regmask;        /* Save register mask.  */
724         long    regoffset;      /* Save register offset.  */
725         long    fregmask;       /* Save floating point register mask.  */
726         long    fregoffset;     /* Save floating point register offset.  */
727         long    frameoffset;    /* Frame size.  */
728         short   framereg;       /* Frame pointer register.  */
729         short   pcreg;          /* Offset or reg of return pc.  */
730         long    irpss;          /* Index into the runtime string table.  */
731         long    reserved;
732         struct exception_info *exception_info;/* Pointer to exception array.  */
733 } RPDR, *pRPDR;
734 #define cbRPDR sizeof (RPDR)
735 #define rpdNil ((pRPDR) 0)
736 \f
737 static struct mips_got_entry *mips_elf_create_local_got_entry
738   (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
739    struct mips_elf_link_hash_entry *, int);
740 static bfd_boolean mips_elf_sort_hash_table_f
741   (struct mips_elf_link_hash_entry *, void *);
742 static bfd_vma mips_elf_high
743   (bfd_vma);
744 static bfd_boolean mips_elf_create_dynamic_relocation
745   (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
746    struct mips_elf_link_hash_entry *, asection *, bfd_vma,
747    bfd_vma *, asection *);
748 static bfd_vma mips_elf_adjust_gp
749   (bfd *, struct mips_got_info *, bfd *);
750
751 /* This will be used when we sort the dynamic relocation records.  */
752 static bfd *reldyn_sorting_bfd;
753
754 /* True if ABFD is for CPUs with load interlocking that include
755    non-MIPS1 CPUs and R3900.  */
756 #define LOAD_INTERLOCKS_P(abfd) \
757   (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
758    || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
759
760 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
761    This should be safe for all architectures.  We enable this predicate
762    for RM9000 for now.  */
763 #define JAL_TO_BAL_P(abfd) \
764   ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
765
766 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
767    This should be safe for all architectures.  We enable this predicate for
768    all CPUs.  */
769 #define JALR_TO_BAL_P(abfd) 1
770
771 /* True if ABFD is for CPUs that are faster if JR is converted to B.
772    This should be safe for all architectures.  We enable this predicate for
773    all CPUs.  */
774 #define JR_TO_B_P(abfd) 1
775
776 /* True if ABFD is a PIC object.  */
777 #define PIC_OBJECT_P(abfd) \
778   ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
779
780 /* Nonzero if ABFD is using the O32 ABI.  */
781 #define ABI_O32_P(abfd) \
782   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
783
784 /* Nonzero if ABFD is using the N32 ABI.  */
785 #define ABI_N32_P(abfd) \
786   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
787
788 /* Nonzero if ABFD is using the N64 ABI.  */
789 #define ABI_64_P(abfd) \
790   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
791
792 /* Nonzero if ABFD is using NewABI conventions.  */
793 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
794
795 /* Nonzero if ABFD has microMIPS code.  */
796 #define MICROMIPS_P(abfd) \
797   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
798
799 /* Nonzero if ABFD is MIPS R6.  */
800 #define MIPSR6_P(abfd) \
801   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
802     || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
803
804 /* The IRIX compatibility level we are striving for.  */
805 #define IRIX_COMPAT(abfd) \
806   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
807
808 /* Whether we are trying to be compatible with IRIX at all.  */
809 #define SGI_COMPAT(abfd) \
810   (IRIX_COMPAT (abfd) != ict_none)
811
812 /* The name of the options section.  */
813 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
814   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
815
816 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
817    Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
818 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
819   (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
820
821 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section.  */
822 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
823   (strcmp (NAME, ".MIPS.abiflags") == 0)
824
825 /* Whether the section is readonly.  */
826 #define MIPS_ELF_READONLY_SECTION(sec) \
827   ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \
828    == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
829
830 /* The name of the stub section.  */
831 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
832
833 /* The size of an external REL relocation.  */
834 #define MIPS_ELF_REL_SIZE(abfd) \
835   (get_elf_backend_data (abfd)->s->sizeof_rel)
836
837 /* The size of an external RELA relocation.  */
838 #define MIPS_ELF_RELA_SIZE(abfd) \
839   (get_elf_backend_data (abfd)->s->sizeof_rela)
840
841 /* The size of an external dynamic table entry.  */
842 #define MIPS_ELF_DYN_SIZE(abfd) \
843   (get_elf_backend_data (abfd)->s->sizeof_dyn)
844
845 /* The size of a GOT entry.  */
846 #define MIPS_ELF_GOT_SIZE(abfd) \
847   (get_elf_backend_data (abfd)->s->arch_size / 8)
848
849 /* The size of the .rld_map section. */
850 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
851   (get_elf_backend_data (abfd)->s->arch_size / 8)
852
853 /* The size of a symbol-table entry.  */
854 #define MIPS_ELF_SYM_SIZE(abfd) \
855   (get_elf_backend_data (abfd)->s->sizeof_sym)
856
857 /* The default alignment for sections, as a power of two.  */
858 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
859   (get_elf_backend_data (abfd)->s->log_file_align)
860
861 /* Get word-sized data.  */
862 #define MIPS_ELF_GET_WORD(abfd, ptr) \
863   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
864
865 /* Put out word-sized data.  */
866 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
867   (ABI_64_P (abfd)                              \
868    ? bfd_put_64 (abfd, val, ptr)                \
869    : bfd_put_32 (abfd, val, ptr))
870
871 /* The opcode for word-sized loads (LW or LD).  */
872 #define MIPS_ELF_LOAD_WORD(abfd) \
873   (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
874
875 /* Add a dynamic symbol table-entry.  */
876 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
877   _bfd_elf_add_dynamic_entry (info, tag, val)
878
879 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
880   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
881
882 /* The name of the dynamic relocation section.  */
883 #define MIPS_ELF_REL_DYN_NAME(INFO) \
884   (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
885
886 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
887    from smaller values.  Start with zero, widen, *then* decrement.  */
888 #define MINUS_ONE       (((bfd_vma)0) - 1)
889 #define MINUS_TWO       (((bfd_vma)0) - 2)
890
891 /* The value to write into got[1] for SVR4 targets, to identify it is
892    a GNU object.  The dynamic linker can then use got[1] to store the
893    module pointer.  */
894 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
895   ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
896
897 /* The offset of $gp from the beginning of the .got section.  */
898 #define ELF_MIPS_GP_OFFSET(INFO) \
899   (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
900
901 /* The maximum size of the GOT for it to be addressable using 16-bit
902    offsets from $gp.  */
903 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
904
905 /* Instructions which appear in a stub.  */
906 #define STUB_LW(abfd)                                                   \
907   ((ABI_64_P (abfd)                                                     \
908     ? 0xdf998010                                /* ld t9,0x8010(gp) */  \
909     : 0x8f998010))                              /* lw t9,0x8010(gp) */
910 #define STUB_MOVE 0x03e07825                    /* or t7,ra,zero */
911 #define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */
912 #define STUB_JALR 0x0320f809                    /* jalr ra,t9 */
913 #define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */
914 #define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */
915 #define STUB_LI16S(abfd, VAL)                                           \
916    ((ABI_64_P (abfd)                                                    \
917     ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \
918     : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */
919
920 /* Likewise for the microMIPS ASE.  */
921 #define STUB_LW_MICROMIPS(abfd)                                         \
922   (ABI_64_P (abfd)                                                      \
923    ? 0xdf3c8010                                 /* ld t9,0x8010(gp) */  \
924    : 0xff3c8010)                                /* lw t9,0x8010(gp) */
925 #define STUB_MOVE_MICROMIPS 0x0dff              /* move t7,ra */
926 #define STUB_MOVE32_MICROMIPS 0x001f7a90        /* or t7,ra,zero */
927 #define STUB_LUI_MICROMIPS(VAL)                                         \
928    (0x41b80000 + (VAL))                         /* lui t8,VAL */
929 #define STUB_JALR_MICROMIPS 0x45d9              /* jalr t9 */
930 #define STUB_JALR32_MICROMIPS 0x03f90f3c        /* jalr ra,t9 */
931 #define STUB_ORI_MICROMIPS(VAL)                                         \
932   (0x53180000 + (VAL))                          /* ori t8,t8,VAL */
933 #define STUB_LI16U_MICROMIPS(VAL)                                       \
934   (0x53000000 + (VAL))                          /* ori t8,zero,VAL unsigned */
935 #define STUB_LI16S_MICROMIPS(abfd, VAL)                                 \
936    (ABI_64_P (abfd)                                                     \
937     ? 0x5f000000 + (VAL)        /* daddiu t8,zero,VAL sign extended */  \
938     : 0x33000000 + (VAL))       /* addiu t8,zero,VAL sign extended */
939
940 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
941 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
942 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
943 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
944 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
945 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
946
947 /* The name of the dynamic interpreter.  This is put in the .interp
948    section.  */
949
950 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
951    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
952     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
953     : "/usr/lib/libc.so.1")
954
955 #ifdef BFD64
956 #define MNAME(bfd,pre,pos) \
957   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
958 #define ELF_R_SYM(bfd, i)                                       \
959   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
960 #define ELF_R_TYPE(bfd, i)                                      \
961   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
962 #define ELF_R_INFO(bfd, s, t)                                   \
963   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
964 #else
965 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
966 #define ELF_R_SYM(bfd, i)                                       \
967   (ELF32_R_SYM (i))
968 #define ELF_R_TYPE(bfd, i)                                      \
969   (ELF32_R_TYPE (i))
970 #define ELF_R_INFO(bfd, s, t)                                   \
971   (ELF32_R_INFO (s, t))
972 #endif
973 \f
974   /* The mips16 compiler uses a couple of special sections to handle
975      floating point arguments.
976
977      Section names that look like .mips16.fn.FNNAME contain stubs that
978      copy floating point arguments from the fp regs to the gp regs and
979      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
980      call should be redirected to the stub instead.  If no 32 bit
981      function calls FNNAME, the stub should be discarded.  We need to
982      consider any reference to the function, not just a call, because
983      if the address of the function is taken we will need the stub,
984      since the address might be passed to a 32 bit function.
985
986      Section names that look like .mips16.call.FNNAME contain stubs
987      that copy floating point arguments from the gp regs to the fp
988      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
989      then any 16 bit function that calls FNNAME should be redirected
990      to the stub instead.  If FNNAME is not a 32 bit function, the
991      stub should be discarded.
992
993      .mips16.call.fp.FNNAME sections are similar, but contain stubs
994      which call FNNAME and then copy the return value from the fp regs
995      to the gp regs.  These stubs store the return value in $18 while
996      calling FNNAME; any function which might call one of these stubs
997      must arrange to save $18 around the call.  (This case is not
998      needed for 32 bit functions that call 16 bit functions, because
999      16 bit functions always return floating point values in both
1000      $f0/$f1 and $2/$3.)
1001
1002      Note that in all cases FNNAME might be defined statically.
1003      Therefore, FNNAME is not used literally.  Instead, the relocation
1004      information will indicate which symbol the section is for.
1005
1006      We record any stubs that we find in the symbol table.  */
1007
1008 #define FN_STUB ".mips16.fn."
1009 #define CALL_STUB ".mips16.call."
1010 #define CALL_FP_STUB ".mips16.call.fp."
1011
1012 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1013 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1014 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
1015 \f
1016 /* The format of the first PLT entry in an O32 executable.  */
1017 static const bfd_vma mips_o32_exec_plt0_entry[] =
1018 {
1019   0x3c1c0000,   /* lui $28, %hi(&GOTPLT[0])                             */
1020   0x8f990000,   /* lw $25, %lo(&GOTPLT[0])($28)                         */
1021   0x279c0000,   /* addiu $28, $28, %lo(&GOTPLT[0])                      */
1022   0x031cc023,   /* subu $24, $24, $28                                   */
1023   0x03e07825,   /* or t7, ra, zero                                      */
1024   0x0018c082,   /* srl $24, $24, 2                                      */
1025   0x0320f809,   /* jalr $25                                             */
1026   0x2718fffe    /* subu $24, $24, 2                                     */
1027 };
1028
1029 /* The format of the first PLT entry in an N32 executable.  Different
1030    because gp ($28) is not available; we use t2 ($14) instead.  */
1031 static const bfd_vma mips_n32_exec_plt0_entry[] =
1032 {
1033   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
1034   0x8dd90000,   /* lw $25, %lo(&GOTPLT[0])($14)                         */
1035   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
1036   0x030ec023,   /* subu $24, $24, $14                                   */
1037   0x03e07825,   /* or t7, ra, zero                                      */
1038   0x0018c082,   /* srl $24, $24, 2                                      */
1039   0x0320f809,   /* jalr $25                                             */
1040   0x2718fffe    /* subu $24, $24, 2                                     */
1041 };
1042
1043 /* The format of the first PLT entry in an N64 executable.  Different
1044    from N32 because of the increased size of GOT entries.  */
1045 static const bfd_vma mips_n64_exec_plt0_entry[] =
1046 {
1047   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
1048   0xddd90000,   /* ld $25, %lo(&GOTPLT[0])($14)                         */
1049   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
1050   0x030ec023,   /* subu $24, $24, $14                                   */
1051   0x03e07825,   /* or t7, ra, zero                                      */
1052   0x0018c0c2,   /* srl $24, $24, 3                                      */
1053   0x0320f809,   /* jalr $25                                             */
1054   0x2718fffe    /* subu $24, $24, 2                                     */
1055 };
1056
1057 /* The format of the microMIPS first PLT entry in an O32 executable.
1058    We rely on v0 ($2) rather than t8 ($24) to contain the address
1059    of the GOTPLT entry handled, so this stub may only be used when
1060    all the subsequent PLT entries are microMIPS code too.
1061
1062    The trailing NOP is for alignment and correct disassembly only.  */
1063 static const bfd_vma micromips_o32_exec_plt0_entry[] =
1064 {
1065   0x7980, 0x0000,       /* addiupc $3, (&GOTPLT[0]) - .                 */
1066   0xff23, 0x0000,       /* lw $25, 0($3)                                */
1067   0x0535,               /* subu $2, $2, $3                              */
1068   0x2525,               /* srl $2, $2, 2                                */
1069   0x3302, 0xfffe,       /* subu $24, $2, 2                              */
1070   0x0dff,               /* move $15, $31                                */
1071   0x45f9,               /* jalrs $25                                    */
1072   0x0f83,               /* move $28, $3                                 */
1073   0x0c00                /* nop                                          */
1074 };
1075
1076 /* The format of the microMIPS first PLT entry in an O32 executable
1077    in the insn32 mode.  */
1078 static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] =
1079 {
1080   0x41bc, 0x0000,       /* lui $28, %hi(&GOTPLT[0])                     */
1081   0xff3c, 0x0000,       /* lw $25, %lo(&GOTPLT[0])($28)                 */
1082   0x339c, 0x0000,       /* addiu $28, $28, %lo(&GOTPLT[0])              */
1083   0x0398, 0xc1d0,       /* subu $24, $24, $28                           */
1084   0x001f, 0x7a90,       /* or $15, $31, zero                            */
1085   0x0318, 0x1040,       /* srl $24, $24, 2                              */
1086   0x03f9, 0x0f3c,       /* jalr $25                                     */
1087   0x3318, 0xfffe        /* subu $24, $24, 2                             */
1088 };
1089
1090 /* The format of subsequent standard PLT entries.  */
1091 static const bfd_vma mips_exec_plt_entry[] =
1092 {
1093   0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
1094   0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
1095   0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
1096   0x03200008    /* jr $25                                       */
1097 };
1098
1099 /* In the following PLT entry the JR and ADDIU instructions will
1100    be swapped in _bfd_mips_elf_finish_dynamic_symbol because
1101    LOAD_INTERLOCKS_P will be true for MIPS R6.  */
1102 static const bfd_vma mipsr6_exec_plt_entry[] =
1103 {
1104   0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
1105   0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
1106   0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
1107   0x03200009    /* jr $25                                       */
1108 };
1109
1110 /* The format of subsequent MIPS16 o32 PLT entries.  We use v0 ($2)
1111    and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1112    directly addressable.  */
1113 static const bfd_vma mips16_o32_exec_plt_entry[] =
1114 {
1115   0xb203,               /* lw $2, 12($pc)                       */
1116   0x9a60,               /* lw $3, 0($2)                         */
1117   0x651a,               /* move $24, $2                         */
1118   0xeb00,               /* jr $3                                */
1119   0x653b,               /* move $25, $3                         */
1120   0x6500,               /* nop                                  */
1121   0x0000, 0x0000        /* .word (.got.plt entry)               */
1122 };
1123
1124 /* The format of subsequent microMIPS o32 PLT entries.  We use v0 ($2)
1125    as a temporary because t8 ($24) is not addressable with ADDIUPC.  */
1126 static const bfd_vma micromips_o32_exec_plt_entry[] =
1127 {
1128   0x7900, 0x0000,       /* addiupc $2, (.got.plt entry) - .     */
1129   0xff22, 0x0000,       /* lw $25, 0($2)                        */
1130   0x4599,               /* jr $25                               */
1131   0x0f02                /* move $24, $2                         */
1132 };
1133
1134 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode.  */
1135 static const bfd_vma micromips_insn32_o32_exec_plt_entry[] =
1136 {
1137   0x41af, 0x0000,       /* lui $15, %hi(.got.plt entry)         */
1138   0xff2f, 0x0000,       /* lw $25, %lo(.got.plt entry)($15)     */
1139   0x0019, 0x0f3c,       /* jr $25                               */
1140   0x330f, 0x0000        /* addiu $24, $15, %lo(.got.plt entry)  */
1141 };
1142
1143 /* The format of the first PLT entry in a VxWorks executable.  */
1144 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
1145 {
1146   0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */
1147   0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */
1148   0x8f390008,   /* lw t9, 8(t9)                                 */
1149   0x00000000,   /* nop                                          */
1150   0x03200008,   /* jr t9                                        */
1151   0x00000000    /* nop                                          */
1152 };
1153
1154 /* The format of subsequent PLT entries.  */
1155 static const bfd_vma mips_vxworks_exec_plt_entry[] =
1156 {
1157   0x10000000,   /* b .PLT_resolver                      */
1158   0x24180000,   /* li t8, <pltindex>                    */
1159   0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */
1160   0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */
1161   0x8f390000,   /* lw t9, 0(t9)                         */
1162   0x00000000,   /* nop                                  */
1163   0x03200008,   /* jr t9                                */
1164   0x00000000    /* nop                                  */
1165 };
1166
1167 /* The format of the first PLT entry in a VxWorks shared object.  */
1168 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1169 {
1170   0x8f990008,   /* lw t9, 8(gp)         */
1171   0x00000000,   /* nop                  */
1172   0x03200008,   /* jr t9                */
1173   0x00000000,   /* nop                  */
1174   0x00000000,   /* nop                  */
1175   0x00000000    /* nop                  */
1176 };
1177
1178 /* The format of subsequent PLT entries.  */
1179 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1180 {
1181   0x10000000,   /* b .PLT_resolver      */
1182   0x24180000    /* li t8, <pltindex>    */
1183 };
1184 \f
1185 /* microMIPS 32-bit opcode helper installer.  */
1186
1187 static void
1188 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1189 {
1190   bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1191   bfd_put_16 (abfd,  opcode        & 0xffff, ptr + 2);
1192 }
1193
1194 /* microMIPS 32-bit opcode helper retriever.  */
1195
1196 static bfd_vma
1197 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1198 {
1199   return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1200 }
1201 \f
1202 /* Look up an entry in a MIPS ELF linker hash table.  */
1203
1204 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
1205   ((struct mips_elf_link_hash_entry *)                                  \
1206    elf_link_hash_lookup (&(table)->root, (string), (create),            \
1207                          (copy), (follow)))
1208
1209 /* Traverse a MIPS ELF linker hash table.  */
1210
1211 #define mips_elf_link_hash_traverse(table, func, info)                  \
1212   (elf_link_hash_traverse                                               \
1213    (&(table)->root,                                                     \
1214     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1215     (info)))
1216
1217 /* Find the base offsets for thread-local storage in this object,
1218    for GD/LD and IE/LE respectively.  */
1219
1220 #define TP_OFFSET 0x7000
1221 #define DTP_OFFSET 0x8000
1222
1223 static bfd_vma
1224 dtprel_base (struct bfd_link_info *info)
1225 {
1226   /* If tls_sec is NULL, we should have signalled an error already.  */
1227   if (elf_hash_table (info)->tls_sec == NULL)
1228     return 0;
1229   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1230 }
1231
1232 static bfd_vma
1233 tprel_base (struct bfd_link_info *info)
1234 {
1235   /* If tls_sec is NULL, we should have signalled an error already.  */
1236   if (elf_hash_table (info)->tls_sec == NULL)
1237     return 0;
1238   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1239 }
1240
1241 /* Create an entry in a MIPS ELF linker hash table.  */
1242
1243 static struct bfd_hash_entry *
1244 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1245                             struct bfd_hash_table *table, const char *string)
1246 {
1247   struct mips_elf_link_hash_entry *ret =
1248     (struct mips_elf_link_hash_entry *) entry;
1249
1250   /* Allocate the structure if it has not already been allocated by a
1251      subclass.  */
1252   if (ret == NULL)
1253     ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1254   if (ret == NULL)
1255     return (struct bfd_hash_entry *) ret;
1256
1257   /* Call the allocation method of the superclass.  */
1258   ret = ((struct mips_elf_link_hash_entry *)
1259          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1260                                      table, string));
1261   if (ret != NULL)
1262     {
1263       /* Set local fields.  */
1264       memset (&ret->esym, 0, sizeof (EXTR));
1265       /* We use -2 as a marker to indicate that the information has
1266          not been set.  -1 means there is no associated ifd.  */
1267       ret->esym.ifd = -2;
1268       ret->la25_stub = 0;
1269       ret->possibly_dynamic_relocs = 0;
1270       ret->fn_stub = NULL;
1271       ret->call_stub = NULL;
1272       ret->call_fp_stub = NULL;
1273       ret->global_got_area = GGA_NONE;
1274       ret->got_only_for_calls = TRUE;
1275       ret->readonly_reloc = FALSE;
1276       ret->has_static_relocs = FALSE;
1277       ret->no_fn_stub = FALSE;
1278       ret->need_fn_stub = FALSE;
1279       ret->has_nonpic_branches = FALSE;
1280       ret->needs_lazy_stub = FALSE;
1281       ret->use_plt_entry = FALSE;
1282     }
1283
1284   return (struct bfd_hash_entry *) ret;
1285 }
1286
1287 /* Allocate MIPS ELF private object data.  */
1288
1289 bfd_boolean
1290 _bfd_mips_elf_mkobject (bfd *abfd)
1291 {
1292   return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
1293                                   MIPS_ELF_DATA);
1294 }
1295
1296 bfd_boolean
1297 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1298 {
1299   if (!sec->used_by_bfd)
1300     {
1301       struct _mips_elf_section_data *sdata;
1302       bfd_size_type amt = sizeof (*sdata);
1303
1304       sdata = bfd_zalloc (abfd, amt);
1305       if (sdata == NULL)
1306         return FALSE;
1307       sec->used_by_bfd = sdata;
1308     }
1309
1310   return _bfd_elf_new_section_hook (abfd, sec);
1311 }
1312 \f
1313 /* Read ECOFF debugging information from a .mdebug section into a
1314    ecoff_debug_info structure.  */
1315
1316 bfd_boolean
1317 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1318                                struct ecoff_debug_info *debug)
1319 {
1320   HDRR *symhdr;
1321   const struct ecoff_debug_swap *swap;
1322   char *ext_hdr;
1323
1324   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1325   memset (debug, 0, sizeof (*debug));
1326
1327   ext_hdr = bfd_malloc (swap->external_hdr_size);
1328   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1329     goto error_return;
1330
1331   if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1332                                   swap->external_hdr_size))
1333     goto error_return;
1334
1335   symhdr = &debug->symbolic_header;
1336   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1337
1338   /* The symbolic header contains absolute file offsets and sizes to
1339      read.  */
1340 #define READ(ptr, offset, count, size, type)                            \
1341   if (symhdr->count == 0)                                               \
1342     debug->ptr = NULL;                                                  \
1343   else                                                                  \
1344     {                                                                   \
1345       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1346       debug->ptr = bfd_malloc (amt);                                    \
1347       if (debug->ptr == NULL)                                           \
1348         goto error_return;                                              \
1349       if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0                \
1350           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1351         goto error_return;                                              \
1352     }
1353
1354   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1355   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1356   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1357   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1358   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1359   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1360         union aux_ext *);
1361   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1362   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1363   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1364   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1365   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1366 #undef READ
1367
1368   debug->fdr = NULL;
1369
1370   return TRUE;
1371
1372  error_return:
1373   if (ext_hdr != NULL)
1374     free (ext_hdr);
1375   if (debug->line != NULL)
1376     free (debug->line);
1377   if (debug->external_dnr != NULL)
1378     free (debug->external_dnr);
1379   if (debug->external_pdr != NULL)
1380     free (debug->external_pdr);
1381   if (debug->external_sym != NULL)
1382     free (debug->external_sym);
1383   if (debug->external_opt != NULL)
1384     free (debug->external_opt);
1385   if (debug->external_aux != NULL)
1386     free (debug->external_aux);
1387   if (debug->ss != NULL)
1388     free (debug->ss);
1389   if (debug->ssext != NULL)
1390     free (debug->ssext);
1391   if (debug->external_fdr != NULL)
1392     free (debug->external_fdr);
1393   if (debug->external_rfd != NULL)
1394     free (debug->external_rfd);
1395   if (debug->external_ext != NULL)
1396     free (debug->external_ext);
1397   return FALSE;
1398 }
1399 \f
1400 /* Swap RPDR (runtime procedure table entry) for output.  */
1401
1402 static void
1403 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1404 {
1405   H_PUT_S32 (abfd, in->adr, ex->p_adr);
1406   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1407   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1408   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1409   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1410   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1411
1412   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1413   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1414
1415   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1416 }
1417
1418 /* Create a runtime procedure table from the .mdebug section.  */
1419
1420 static bfd_boolean
1421 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1422                                  struct bfd_link_info *info, asection *s,
1423                                  struct ecoff_debug_info *debug)
1424 {
1425   const struct ecoff_debug_swap *swap;
1426   HDRR *hdr = &debug->symbolic_header;
1427   RPDR *rpdr, *rp;
1428   struct rpdr_ext *erp;
1429   void *rtproc;
1430   struct pdr_ext *epdr;
1431   struct sym_ext *esym;
1432   char *ss, **sv;
1433   char *str;
1434   bfd_size_type size;
1435   bfd_size_type count;
1436   unsigned long sindex;
1437   unsigned long i;
1438   PDR pdr;
1439   SYMR sym;
1440   const char *no_name_func = _("static procedure (no name)");
1441
1442   epdr = NULL;
1443   rpdr = NULL;
1444   esym = NULL;
1445   ss = NULL;
1446   sv = NULL;
1447
1448   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1449
1450   sindex = strlen (no_name_func) + 1;
1451   count = hdr->ipdMax;
1452   if (count > 0)
1453     {
1454       size = swap->external_pdr_size;
1455
1456       epdr = bfd_malloc (size * count);
1457       if (epdr == NULL)
1458         goto error_return;
1459
1460       if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1461         goto error_return;
1462
1463       size = sizeof (RPDR);
1464       rp = rpdr = bfd_malloc (size * count);
1465       if (rpdr == NULL)
1466         goto error_return;
1467
1468       size = sizeof (char *);
1469       sv = bfd_malloc (size * count);
1470       if (sv == NULL)
1471         goto error_return;
1472
1473       count = hdr->isymMax;
1474       size = swap->external_sym_size;
1475       esym = bfd_malloc (size * count);
1476       if (esym == NULL)
1477         goto error_return;
1478
1479       if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1480         goto error_return;
1481
1482       count = hdr->issMax;
1483       ss = bfd_malloc (count);
1484       if (ss == NULL)
1485         goto error_return;
1486       if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1487         goto error_return;
1488
1489       count = hdr->ipdMax;
1490       for (i = 0; i < (unsigned long) count; i++, rp++)
1491         {
1492           (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1493           (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1494           rp->adr = sym.value;
1495           rp->regmask = pdr.regmask;
1496           rp->regoffset = pdr.regoffset;
1497           rp->fregmask = pdr.fregmask;
1498           rp->fregoffset = pdr.fregoffset;
1499           rp->frameoffset = pdr.frameoffset;
1500           rp->framereg = pdr.framereg;
1501           rp->pcreg = pdr.pcreg;
1502           rp->irpss = sindex;
1503           sv[i] = ss + sym.iss;
1504           sindex += strlen (sv[i]) + 1;
1505         }
1506     }
1507
1508   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1509   size = BFD_ALIGN (size, 16);
1510   rtproc = bfd_alloc (abfd, size);
1511   if (rtproc == NULL)
1512     {
1513       mips_elf_hash_table (info)->procedure_count = 0;
1514       goto error_return;
1515     }
1516
1517   mips_elf_hash_table (info)->procedure_count = count + 2;
1518
1519   erp = rtproc;
1520   memset (erp, 0, sizeof (struct rpdr_ext));
1521   erp++;
1522   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1523   strcpy (str, no_name_func);
1524   str += strlen (no_name_func) + 1;
1525   for (i = 0; i < count; i++)
1526     {
1527       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1528       strcpy (str, sv[i]);
1529       str += strlen (sv[i]) + 1;
1530     }
1531   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1532
1533   /* Set the size and contents of .rtproc section.  */
1534   s->size = size;
1535   s->contents = rtproc;
1536
1537   /* Skip this section later on (I don't think this currently
1538      matters, but someday it might).  */
1539   s->map_head.link_order = NULL;
1540
1541   if (epdr != NULL)
1542     free (epdr);
1543   if (rpdr != NULL)
1544     free (rpdr);
1545   if (esym != NULL)
1546     free (esym);
1547   if (ss != NULL)
1548     free (ss);
1549   if (sv != NULL)
1550     free (sv);
1551
1552   return TRUE;
1553
1554  error_return:
1555   if (epdr != NULL)
1556     free (epdr);
1557   if (rpdr != NULL)
1558     free (rpdr);
1559   if (esym != NULL)
1560     free (esym);
1561   if (ss != NULL)
1562     free (ss);
1563   if (sv != NULL)
1564     free (sv);
1565   return FALSE;
1566 }
1567 \f
1568 /* We're going to create a stub for H.  Create a symbol for the stub's
1569    value and size, to help make the disassembly easier to read.  */
1570
1571 static bfd_boolean
1572 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1573                              struct mips_elf_link_hash_entry *h,
1574                              const char *prefix, asection *s, bfd_vma value,
1575                              bfd_vma size)
1576 {
1577   bfd_boolean micromips_p = ELF_ST_IS_MICROMIPS (h->root.other);
1578   struct bfd_link_hash_entry *bh;
1579   struct elf_link_hash_entry *elfh;
1580   char *name;
1581   bfd_boolean res;
1582
1583   if (micromips_p)
1584     value |= 1;
1585
1586   /* Create a new symbol.  */
1587   name = concat (prefix, h->root.root.root.string, NULL);
1588   bh = NULL;
1589   res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1590                                           BSF_LOCAL, s, value, NULL,
1591                                           TRUE, FALSE, &bh);
1592   free (name);
1593   if (! res)
1594     return FALSE;
1595
1596   /* Make it a local function.  */
1597   elfh = (struct elf_link_hash_entry *) bh;
1598   elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1599   elfh->size = size;
1600   elfh->forced_local = 1;
1601   if (micromips_p)
1602     elfh->other = ELF_ST_SET_MICROMIPS (elfh->other);
1603   return TRUE;
1604 }
1605
1606 /* We're about to redefine H.  Create a symbol to represent H's
1607    current value and size, to help make the disassembly easier
1608    to read.  */
1609
1610 static bfd_boolean
1611 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1612                                struct mips_elf_link_hash_entry *h,
1613                                const char *prefix)
1614 {
1615   struct bfd_link_hash_entry *bh;
1616   struct elf_link_hash_entry *elfh;
1617   char *name;
1618   asection *s;
1619   bfd_vma value;
1620   bfd_boolean res;
1621
1622   /* Read the symbol's value.  */
1623   BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1624               || h->root.root.type == bfd_link_hash_defweak);
1625   s = h->root.root.u.def.section;
1626   value = h->root.root.u.def.value;
1627
1628   /* Create a new symbol.  */
1629   name = concat (prefix, h->root.root.root.string, NULL);
1630   bh = NULL;
1631   res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1632                                           BSF_LOCAL, s, value, NULL,
1633                                           TRUE, FALSE, &bh);
1634   free (name);
1635   if (! res)
1636     return FALSE;
1637
1638   /* Make it local and copy the other attributes from H.  */
1639   elfh = (struct elf_link_hash_entry *) bh;
1640   elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1641   elfh->other = h->root.other;
1642   elfh->size = h->root.size;
1643   elfh->forced_local = 1;
1644   return TRUE;
1645 }
1646
1647 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1648    function rather than to a hard-float stub.  */
1649
1650 static bfd_boolean
1651 section_allows_mips16_refs_p (asection *section)
1652 {
1653   const char *name;
1654
1655   name = bfd_get_section_name (section->owner, section);
1656   return (FN_STUB_P (name)
1657           || CALL_STUB_P (name)
1658           || CALL_FP_STUB_P (name)
1659           || strcmp (name, ".pdr") == 0);
1660 }
1661
1662 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1663    stub section of some kind.  Return the R_SYMNDX of the target
1664    function, or 0 if we can't decide which function that is.  */
1665
1666 static unsigned long
1667 mips16_stub_symndx (const struct elf_backend_data *bed,
1668                     asection *sec ATTRIBUTE_UNUSED,
1669                     const Elf_Internal_Rela *relocs,
1670                     const Elf_Internal_Rela *relend)
1671 {
1672   int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
1673   const Elf_Internal_Rela *rel;
1674
1675   /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1676      one in a compound relocation.  */
1677   for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
1678     if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1679       return ELF_R_SYM (sec->owner, rel->r_info);
1680
1681   /* Otherwise trust the first relocation, whatever its kind.  This is
1682      the traditional behavior.  */
1683   if (relocs < relend)
1684     return ELF_R_SYM (sec->owner, relocs->r_info);
1685
1686   return 0;
1687 }
1688
1689 /* Check the mips16 stubs for a particular symbol, and see if we can
1690    discard them.  */
1691
1692 static void
1693 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1694                              struct mips_elf_link_hash_entry *h)
1695 {
1696   /* Dynamic symbols must use the standard call interface, in case other
1697      objects try to call them.  */
1698   if (h->fn_stub != NULL
1699       && h->root.dynindx != -1)
1700     {
1701       mips_elf_create_shadow_symbol (info, h, ".mips16.");
1702       h->need_fn_stub = TRUE;
1703     }
1704
1705   if (h->fn_stub != NULL
1706       && ! h->need_fn_stub)
1707     {
1708       /* We don't need the fn_stub; the only references to this symbol
1709          are 16 bit calls.  Clobber the size to 0 to prevent it from
1710          being included in the link.  */
1711       h->fn_stub->size = 0;
1712       h->fn_stub->flags &= ~SEC_RELOC;
1713       h->fn_stub->reloc_count = 0;
1714       h->fn_stub->flags |= SEC_EXCLUDE;
1715       h->fn_stub->output_section = bfd_abs_section_ptr;
1716     }
1717
1718   if (h->call_stub != NULL
1719       && ELF_ST_IS_MIPS16 (h->root.other))
1720     {
1721       /* We don't need the call_stub; this is a 16 bit function, so
1722          calls from other 16 bit functions are OK.  Clobber the size
1723          to 0 to prevent it from being included in the link.  */
1724       h->call_stub->size = 0;
1725       h->call_stub->flags &= ~SEC_RELOC;
1726       h->call_stub->reloc_count = 0;
1727       h->call_stub->flags |= SEC_EXCLUDE;
1728       h->call_stub->output_section = bfd_abs_section_ptr;
1729     }
1730
1731   if (h->call_fp_stub != NULL
1732       && ELF_ST_IS_MIPS16 (h->root.other))
1733     {
1734       /* We don't need the call_stub; this is a 16 bit function, so
1735          calls from other 16 bit functions are OK.  Clobber the size
1736          to 0 to prevent it from being included in the link.  */
1737       h->call_fp_stub->size = 0;
1738       h->call_fp_stub->flags &= ~SEC_RELOC;
1739       h->call_fp_stub->reloc_count = 0;
1740       h->call_fp_stub->flags |= SEC_EXCLUDE;
1741       h->call_fp_stub->output_section = bfd_abs_section_ptr;
1742     }
1743 }
1744
1745 /* Hashtable callbacks for mips_elf_la25_stubs.  */
1746
1747 static hashval_t
1748 mips_elf_la25_stub_hash (const void *entry_)
1749 {
1750   const struct mips_elf_la25_stub *entry;
1751
1752   entry = (struct mips_elf_la25_stub *) entry_;
1753   return entry->h->root.root.u.def.section->id
1754     + entry->h->root.root.u.def.value;
1755 }
1756
1757 static int
1758 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1759 {
1760   const struct mips_elf_la25_stub *entry1, *entry2;
1761
1762   entry1 = (struct mips_elf_la25_stub *) entry1_;
1763   entry2 = (struct mips_elf_la25_stub *) entry2_;
1764   return ((entry1->h->root.root.u.def.section
1765            == entry2->h->root.root.u.def.section)
1766           && (entry1->h->root.root.u.def.value
1767               == entry2->h->root.root.u.def.value));
1768 }
1769
1770 /* Called by the linker to set up the la25 stub-creation code.  FN is
1771    the linker's implementation of add_stub_function.  Return true on
1772    success.  */
1773
1774 bfd_boolean
1775 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1776                           asection *(*fn) (const char *, asection *,
1777                                            asection *))
1778 {
1779   struct mips_elf_link_hash_table *htab;
1780
1781   htab = mips_elf_hash_table (info);
1782   if (htab == NULL)
1783     return FALSE;
1784
1785   htab->add_stub_section = fn;
1786   htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1787                                       mips_elf_la25_stub_eq, NULL);
1788   if (htab->la25_stubs == NULL)
1789     return FALSE;
1790
1791   return TRUE;
1792 }
1793
1794 /* Return true if H is a locally-defined PIC function, in the sense
1795    that it or its fn_stub might need $25 to be valid on entry.
1796    Note that MIPS16 functions set up $gp using PC-relative instructions,
1797    so they themselves never need $25 to be valid.  Only non-MIPS16
1798    entry points are of interest here.  */
1799
1800 static bfd_boolean
1801 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1802 {
1803   return ((h->root.root.type == bfd_link_hash_defined
1804            || h->root.root.type == bfd_link_hash_defweak)
1805           && h->root.def_regular
1806           && !bfd_is_abs_section (h->root.root.u.def.section)
1807           && !bfd_is_und_section (h->root.root.u.def.section)
1808           && (!ELF_ST_IS_MIPS16 (h->root.other)
1809               || (h->fn_stub && h->need_fn_stub))
1810           && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1811               || ELF_ST_IS_MIPS_PIC (h->root.other)));
1812 }
1813
1814 /* Set *SEC to the input section that contains the target of STUB.
1815    Return the offset of the target from the start of that section.  */
1816
1817 static bfd_vma
1818 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1819                           asection **sec)
1820 {
1821   if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1822     {
1823       BFD_ASSERT (stub->h->need_fn_stub);
1824       *sec = stub->h->fn_stub;
1825       return 0;
1826     }
1827   else
1828     {
1829       *sec = stub->h->root.root.u.def.section;
1830       return stub->h->root.root.u.def.value;
1831     }
1832 }
1833
1834 /* STUB describes an la25 stub that we have decided to implement
1835    by inserting an LUI/ADDIU pair before the target function.
1836    Create the section and redirect the function symbol to it.  */
1837
1838 static bfd_boolean
1839 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1840                          struct bfd_link_info *info)
1841 {
1842   struct mips_elf_link_hash_table *htab;
1843   char *name;
1844   asection *s, *input_section;
1845   unsigned int align;
1846
1847   htab = mips_elf_hash_table (info);
1848   if (htab == NULL)
1849     return FALSE;
1850
1851   /* Create a unique name for the new section.  */
1852   name = bfd_malloc (11 + sizeof (".text.stub."));
1853   if (name == NULL)
1854     return FALSE;
1855   sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1856
1857   /* Create the section.  */
1858   mips_elf_get_la25_target (stub, &input_section);
1859   s = htab->add_stub_section (name, input_section,
1860                               input_section->output_section);
1861   if (s == NULL)
1862     return FALSE;
1863
1864   /* Make sure that any padding goes before the stub.  */
1865   align = input_section->alignment_power;
1866   if (!bfd_set_section_alignment (s->owner, s, align))
1867     return FALSE;
1868   if (align > 3)
1869     s->size = (1 << align) - 8;
1870
1871   /* Create a symbol for the stub.  */
1872   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1873   stub->stub_section = s;
1874   stub->offset = s->size;
1875
1876   /* Allocate room for it.  */
1877   s->size += 8;
1878   return TRUE;
1879 }
1880
1881 /* STUB describes an la25 stub that we have decided to implement
1882    with a separate trampoline.  Allocate room for it and redirect
1883    the function symbol to it.  */
1884
1885 static bfd_boolean
1886 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1887                               struct bfd_link_info *info)
1888 {
1889   struct mips_elf_link_hash_table *htab;
1890   asection *s;
1891
1892   htab = mips_elf_hash_table (info);
1893   if (htab == NULL)
1894     return FALSE;
1895
1896   /* Create a trampoline section, if we haven't already.  */
1897   s = htab->strampoline;
1898   if (s == NULL)
1899     {
1900       asection *input_section = stub->h->root.root.u.def.section;
1901       s = htab->add_stub_section (".text", NULL,
1902                                   input_section->output_section);
1903       if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1904         return FALSE;
1905       htab->strampoline = s;
1906     }
1907
1908   /* Create a symbol for the stub.  */
1909   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1910   stub->stub_section = s;
1911   stub->offset = s->size;
1912
1913   /* Allocate room for it.  */
1914   s->size += 16;
1915   return TRUE;
1916 }
1917
1918 /* H describes a symbol that needs an la25 stub.  Make sure that an
1919    appropriate stub exists and point H at it.  */
1920
1921 static bfd_boolean
1922 mips_elf_add_la25_stub (struct bfd_link_info *info,
1923                         struct mips_elf_link_hash_entry *h)
1924 {
1925   struct mips_elf_link_hash_table *htab;
1926   struct mips_elf_la25_stub search, *stub;
1927   bfd_boolean use_trampoline_p;
1928   asection *s;
1929   bfd_vma value;
1930   void **slot;
1931
1932   /* Describe the stub we want.  */
1933   search.stub_section = NULL;
1934   search.offset = 0;
1935   search.h = h;
1936
1937   /* See if we've already created an equivalent stub.  */
1938   htab = mips_elf_hash_table (info);
1939   if (htab == NULL)
1940     return FALSE;
1941
1942   slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1943   if (slot == NULL)
1944     return FALSE;
1945
1946   stub = (struct mips_elf_la25_stub *) *slot;
1947   if (stub != NULL)
1948     {
1949       /* We can reuse the existing stub.  */
1950       h->la25_stub = stub;
1951       return TRUE;
1952     }
1953
1954   /* Create a permanent copy of ENTRY and add it to the hash table.  */
1955   stub = bfd_malloc (sizeof (search));
1956   if (stub == NULL)
1957     return FALSE;
1958   *stub = search;
1959   *slot = stub;
1960
1961   /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1962      of the section and if we would need no more than 2 nops.  */
1963   value = mips_elf_get_la25_target (stub, &s);
1964   if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
1965     value &= ~1;
1966   use_trampoline_p = (value != 0 || s->alignment_power > 4);
1967
1968   h->la25_stub = stub;
1969   return (use_trampoline_p
1970           ? mips_elf_add_la25_trampoline (stub, info)
1971           : mips_elf_add_la25_intro (stub, info));
1972 }
1973
1974 /* A mips_elf_link_hash_traverse callback that is called before sizing
1975    sections.  DATA points to a mips_htab_traverse_info structure.  */
1976
1977 static bfd_boolean
1978 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1979 {
1980   struct mips_htab_traverse_info *hti;
1981
1982   hti = (struct mips_htab_traverse_info *) data;
1983   if (!bfd_link_relocatable (hti->info))
1984     mips_elf_check_mips16_stubs (hti->info, h);
1985
1986   if (mips_elf_local_pic_function_p (h))
1987     {
1988       /* PR 12845: If H is in a section that has been garbage
1989          collected it will have its output section set to *ABS*.  */
1990       if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1991         return TRUE;
1992
1993       /* H is a function that might need $25 to be valid on entry.
1994          If we're creating a non-PIC relocatable object, mark H as
1995          being PIC.  If we're creating a non-relocatable object with
1996          non-PIC branches and jumps to H, make sure that H has an la25
1997          stub.  */
1998       if (bfd_link_relocatable (hti->info))
1999         {
2000           if (!PIC_OBJECT_P (hti->output_bfd))
2001             h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
2002         }
2003       else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
2004         {
2005           hti->error = TRUE;
2006           return FALSE;
2007         }
2008     }
2009   return TRUE;
2010 }
2011 \f
2012 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2013    Most mips16 instructions are 16 bits, but these instructions
2014    are 32 bits.
2015
2016    The format of these instructions is:
2017
2018    +--------------+--------------------------------+
2019    |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
2020    +--------------+--------------------------------+
2021    |                Immediate  15:0                |
2022    +-----------------------------------------------+
2023
2024    JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
2025    Note that the immediate value in the first word is swapped.
2026
2027    When producing a relocatable object file, R_MIPS16_26 is
2028    handled mostly like R_MIPS_26.  In particular, the addend is
2029    stored as a straight 26-bit value in a 32-bit instruction.
2030    (gas makes life simpler for itself by never adjusting a
2031    R_MIPS16_26 reloc to be against a section, so the addend is
2032    always zero).  However, the 32 bit instruction is stored as 2
2033    16-bit values, rather than a single 32-bit value.  In a
2034    big-endian file, the result is the same; in a little-endian
2035    file, the two 16-bit halves of the 32 bit value are swapped.
2036    This is so that a disassembler can recognize the jal
2037    instruction.
2038
2039    When doing a final link, R_MIPS16_26 is treated as a 32 bit
2040    instruction stored as two 16-bit values.  The addend A is the
2041    contents of the targ26 field.  The calculation is the same as
2042    R_MIPS_26.  When storing the calculated value, reorder the
2043    immediate value as shown above, and don't forget to store the
2044    value as two 16-bit values.
2045
2046    To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2047    defined as
2048
2049    big-endian:
2050    +--------+----------------------+
2051    |        |                      |
2052    |        |    targ26-16         |
2053    |31    26|25                   0|
2054    +--------+----------------------+
2055
2056    little-endian:
2057    +----------+------+-------------+
2058    |          |      |             |
2059    |  sub1    |      |     sub2    |
2060    |0        9|10  15|16         31|
2061    +----------+--------------------+
2062    where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2063    ((sub1 << 16) | sub2)).
2064
2065    When producing a relocatable object file, the calculation is
2066    (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2067    When producing a fully linked file, the calculation is
2068    let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2069    ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2070
2071    The table below lists the other MIPS16 instruction relocations.
2072    Each one is calculated in the same way as the non-MIPS16 relocation
2073    given on the right, but using the extended MIPS16 layout of 16-bit
2074    immediate fields:
2075
2076         R_MIPS16_GPREL          R_MIPS_GPREL16
2077         R_MIPS16_GOT16          R_MIPS_GOT16
2078         R_MIPS16_CALL16         R_MIPS_CALL16
2079         R_MIPS16_HI16           R_MIPS_HI16
2080         R_MIPS16_LO16           R_MIPS_LO16
2081
2082    A typical instruction will have a format like this:
2083
2084    +--------------+--------------------------------+
2085    |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
2086    +--------------+--------------------------------+
2087    |    Major     |   rx   |   ry   |   Imm  4:0   |
2088    +--------------+--------------------------------+
2089
2090    EXTEND is the five bit value 11110.  Major is the instruction
2091    opcode.
2092
2093    All we need to do here is shuffle the bits appropriately.
2094    As above, the two 16-bit halves must be swapped on a
2095    little-endian system.
2096
2097    Finally R_MIPS16_PC16_S1 corresponds to R_MIPS_PC16, however the
2098    relocatable field is shifted by 1 rather than 2 and the same bit
2099    shuffling is done as with the relocations above.  */
2100
2101 static inline bfd_boolean
2102 mips16_reloc_p (int r_type)
2103 {
2104   switch (r_type)
2105     {
2106     case R_MIPS16_26:
2107     case R_MIPS16_GPREL:
2108     case R_MIPS16_GOT16:
2109     case R_MIPS16_CALL16:
2110     case R_MIPS16_HI16:
2111     case R_MIPS16_LO16:
2112     case R_MIPS16_TLS_GD:
2113     case R_MIPS16_TLS_LDM:
2114     case R_MIPS16_TLS_DTPREL_HI16:
2115     case R_MIPS16_TLS_DTPREL_LO16:
2116     case R_MIPS16_TLS_GOTTPREL:
2117     case R_MIPS16_TLS_TPREL_HI16:
2118     case R_MIPS16_TLS_TPREL_LO16:
2119     case R_MIPS16_PC16_S1:
2120       return TRUE;
2121
2122     default:
2123       return FALSE;
2124     }
2125 }
2126
2127 /* Check if a microMIPS reloc.  */
2128
2129 static inline bfd_boolean
2130 micromips_reloc_p (unsigned int r_type)
2131 {
2132   return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
2133 }
2134
2135 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2136    on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
2137    and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.  */
2138
2139 static inline bfd_boolean
2140 micromips_reloc_shuffle_p (unsigned int r_type)
2141 {
2142   return (micromips_reloc_p (r_type)
2143           && r_type != R_MICROMIPS_PC7_S1
2144           && r_type != R_MICROMIPS_PC10_S1);
2145 }
2146
2147 static inline bfd_boolean
2148 got16_reloc_p (int r_type)
2149 {
2150   return (r_type == R_MIPS_GOT16
2151           || r_type == R_MIPS16_GOT16
2152           || r_type == R_MICROMIPS_GOT16);
2153 }
2154
2155 static inline bfd_boolean
2156 call16_reloc_p (int r_type)
2157 {
2158   return (r_type == R_MIPS_CALL16
2159           || r_type == R_MIPS16_CALL16
2160           || r_type == R_MICROMIPS_CALL16);
2161 }
2162
2163 static inline bfd_boolean
2164 got_disp_reloc_p (unsigned int r_type)
2165 {
2166   return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
2167 }
2168
2169 static inline bfd_boolean
2170 got_page_reloc_p (unsigned int r_type)
2171 {
2172   return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
2173 }
2174
2175 static inline bfd_boolean
2176 got_lo16_reloc_p (unsigned int r_type)
2177 {
2178   return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
2179 }
2180
2181 static inline bfd_boolean
2182 call_hi16_reloc_p (unsigned int r_type)
2183 {
2184   return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2185 }
2186
2187 static inline bfd_boolean
2188 call_lo16_reloc_p (unsigned int r_type)
2189 {
2190   return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
2191 }
2192
2193 static inline bfd_boolean
2194 hi16_reloc_p (int r_type)
2195 {
2196   return (r_type == R_MIPS_HI16
2197           || r_type == R_MIPS16_HI16
2198           || r_type == R_MICROMIPS_HI16
2199           || r_type == R_MIPS_PCHI16);
2200 }
2201
2202 static inline bfd_boolean
2203 lo16_reloc_p (int r_type)
2204 {
2205   return (r_type == R_MIPS_LO16
2206           || r_type == R_MIPS16_LO16
2207           || r_type == R_MICROMIPS_LO16
2208           || r_type == R_MIPS_PCLO16);
2209 }
2210
2211 static inline bfd_boolean
2212 mips16_call_reloc_p (int r_type)
2213 {
2214   return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2215 }
2216
2217 static inline bfd_boolean
2218 jal_reloc_p (int r_type)
2219 {
2220   return (r_type == R_MIPS_26
2221           || r_type == R_MIPS16_26
2222           || r_type == R_MICROMIPS_26_S1);
2223 }
2224
2225 static inline bfd_boolean
2226 b_reloc_p (int r_type)
2227 {
2228   return (r_type == R_MIPS_PC26_S2
2229           || r_type == R_MIPS_PC21_S2
2230           || r_type == R_MIPS_PC16
2231           || r_type == R_MIPS_GNU_REL16_S2
2232           || r_type == R_MIPS16_PC16_S1
2233           || r_type == R_MICROMIPS_PC16_S1
2234           || r_type == R_MICROMIPS_PC10_S1
2235           || r_type == R_MICROMIPS_PC7_S1);
2236 }
2237
2238 static inline bfd_boolean
2239 aligned_pcrel_reloc_p (int r_type)
2240 {
2241   return (r_type == R_MIPS_PC18_S3
2242           || r_type == R_MIPS_PC19_S2);
2243 }
2244
2245 static inline bfd_boolean
2246 branch_reloc_p (int r_type)
2247 {
2248   return (r_type == R_MIPS_26
2249           || r_type == R_MIPS_PC26_S2
2250           || r_type == R_MIPS_PC21_S2
2251           || r_type == R_MIPS_PC16
2252           || r_type == R_MIPS_GNU_REL16_S2);
2253 }
2254
2255 static inline bfd_boolean
2256 mips16_branch_reloc_p (int r_type)
2257 {
2258   return (r_type == R_MIPS16_26
2259           || r_type == R_MIPS16_PC16_S1);
2260 }
2261
2262 static inline bfd_boolean
2263 micromips_branch_reloc_p (int r_type)
2264 {
2265   return (r_type == R_MICROMIPS_26_S1
2266           || r_type == R_MICROMIPS_PC16_S1
2267           || r_type == R_MICROMIPS_PC10_S1
2268           || r_type == R_MICROMIPS_PC7_S1);
2269 }
2270
2271 static inline bfd_boolean
2272 tls_gd_reloc_p (unsigned int r_type)
2273 {
2274   return (r_type == R_MIPS_TLS_GD
2275           || r_type == R_MIPS16_TLS_GD
2276           || r_type == R_MICROMIPS_TLS_GD);
2277 }
2278
2279 static inline bfd_boolean
2280 tls_ldm_reloc_p (unsigned int r_type)
2281 {
2282   return (r_type == R_MIPS_TLS_LDM
2283           || r_type == R_MIPS16_TLS_LDM
2284           || r_type == R_MICROMIPS_TLS_LDM);
2285 }
2286
2287 static inline bfd_boolean
2288 tls_gottprel_reloc_p (unsigned int r_type)
2289 {
2290   return (r_type == R_MIPS_TLS_GOTTPREL
2291           || r_type == R_MIPS16_TLS_GOTTPREL
2292           || r_type == R_MICROMIPS_TLS_GOTTPREL);
2293 }
2294
2295 void
2296 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2297                                bfd_boolean jal_shuffle, bfd_byte *data)
2298 {
2299   bfd_vma first, second, val;
2300
2301   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2302     return;
2303
2304   /* Pick up the first and second halfwords of the instruction.  */
2305   first = bfd_get_16 (abfd, data);
2306   second = bfd_get_16 (abfd, data + 2);
2307   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2308     val = first << 16 | second;
2309   else if (r_type != R_MIPS16_26)
2310     val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2311            | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2312   else
2313     val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2314            | ((first & 0x1f) << 21) | second);
2315   bfd_put_32 (abfd, val, data);
2316 }
2317
2318 void
2319 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2320                              bfd_boolean jal_shuffle, bfd_byte *data)
2321 {
2322   bfd_vma first, second, val;
2323
2324   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2325     return;
2326
2327   val = bfd_get_32 (abfd, data);
2328   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2329     {
2330       second = val & 0xffff;
2331       first = val >> 16;
2332     }
2333   else if (r_type != R_MIPS16_26)
2334     {
2335       second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2336       first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2337     }
2338   else
2339     {
2340       second = val & 0xffff;
2341       first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2342                | ((val >> 21) & 0x1f);
2343     }
2344   bfd_put_16 (abfd, second, data + 2);
2345   bfd_put_16 (abfd, first, data);
2346 }
2347
2348 bfd_reloc_status_type
2349 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2350                                arelent *reloc_entry, asection *input_section,
2351                                bfd_boolean relocatable, void *data, bfd_vma gp)
2352 {
2353   bfd_vma relocation;
2354   bfd_signed_vma val;
2355   bfd_reloc_status_type status;
2356
2357   if (bfd_is_com_section (symbol->section))
2358     relocation = 0;
2359   else
2360     relocation = symbol->value;
2361
2362   relocation += symbol->section->output_section->vma;
2363   relocation += symbol->section->output_offset;
2364
2365   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2366     return bfd_reloc_outofrange;
2367
2368   /* Set val to the offset into the section or symbol.  */
2369   val = reloc_entry->addend;
2370
2371   _bfd_mips_elf_sign_extend (val, 16);
2372
2373   /* Adjust val for the final section location and GP value.  If we
2374      are producing relocatable output, we don't want to do this for
2375      an external symbol.  */
2376   if (! relocatable
2377       || (symbol->flags & BSF_SECTION_SYM) != 0)
2378     val += relocation - gp;
2379
2380   if (reloc_entry->howto->partial_inplace)
2381     {
2382       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2383                                        (bfd_byte *) data
2384                                        + reloc_entry->address);
2385       if (status != bfd_reloc_ok)
2386         return status;
2387     }
2388   else
2389     reloc_entry->addend = val;
2390
2391   if (relocatable)
2392     reloc_entry->address += input_section->output_offset;
2393
2394   return bfd_reloc_ok;
2395 }
2396
2397 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2398    R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
2399    that contains the relocation field and DATA points to the start of
2400    INPUT_SECTION.  */
2401
2402 struct mips_hi16
2403 {
2404   struct mips_hi16 *next;
2405   bfd_byte *data;
2406   asection *input_section;
2407   arelent rel;
2408 };
2409
2410 /* FIXME: This should not be a static variable.  */
2411
2412 static struct mips_hi16 *mips_hi16_list;
2413
2414 /* A howto special_function for REL *HI16 relocations.  We can only
2415    calculate the correct value once we've seen the partnering
2416    *LO16 relocation, so just save the information for later.
2417
2418    The ABI requires that the *LO16 immediately follow the *HI16.
2419    However, as a GNU extension, we permit an arbitrary number of
2420    *HI16s to be associated with a single *LO16.  This significantly
2421    simplies the relocation handling in gcc.  */
2422
2423 bfd_reloc_status_type
2424 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2425                           asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2426                           asection *input_section, bfd *output_bfd,
2427                           char **error_message ATTRIBUTE_UNUSED)
2428 {
2429   struct mips_hi16 *n;
2430
2431   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2432     return bfd_reloc_outofrange;
2433
2434   n = bfd_malloc (sizeof *n);
2435   if (n == NULL)
2436     return bfd_reloc_outofrange;
2437
2438   n->next = mips_hi16_list;
2439   n->data = data;
2440   n->input_section = input_section;
2441   n->rel = *reloc_entry;
2442   mips_hi16_list = n;
2443
2444   if (output_bfd != NULL)
2445     reloc_entry->address += input_section->output_offset;
2446
2447   return bfd_reloc_ok;
2448 }
2449
2450 /* A howto special_function for REL R_MIPS*_GOT16 relocations.  This is just
2451    like any other 16-bit relocation when applied to global symbols, but is
2452    treated in the same as R_MIPS_HI16 when applied to local symbols.  */
2453
2454 bfd_reloc_status_type
2455 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2456                            void *data, asection *input_section,
2457                            bfd *output_bfd, char **error_message)
2458 {
2459   if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2460       || bfd_is_und_section (bfd_get_section (symbol))
2461       || bfd_is_com_section (bfd_get_section (symbol)))
2462     /* The relocation is against a global symbol.  */
2463     return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2464                                         input_section, output_bfd,
2465                                         error_message);
2466
2467   return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2468                                    input_section, output_bfd, error_message);
2469 }
2470
2471 /* A howto special_function for REL *LO16 relocations.  The *LO16 itself
2472    is a straightforward 16 bit inplace relocation, but we must deal with
2473    any partnering high-part relocations as well.  */
2474
2475 bfd_reloc_status_type
2476 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2477                           void *data, asection *input_section,
2478                           bfd *output_bfd, char **error_message)
2479 {
2480   bfd_vma vallo;
2481   bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2482
2483   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2484     return bfd_reloc_outofrange;
2485
2486   _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2487                                  location);
2488   vallo = bfd_get_32 (abfd, location);
2489   _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2490                                location);
2491
2492   while (mips_hi16_list != NULL)
2493     {
2494       bfd_reloc_status_type ret;
2495       struct mips_hi16 *hi;
2496
2497       hi = mips_hi16_list;
2498
2499       /* R_MIPS*_GOT16 relocations are something of a special case.  We
2500          want to install the addend in the same way as for a R_MIPS*_HI16
2501          relocation (with a rightshift of 16).  However, since GOT16
2502          relocations can also be used with global symbols, their howto
2503          has a rightshift of 0.  */
2504       if (hi->rel.howto->type == R_MIPS_GOT16)
2505         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2506       else if (hi->rel.howto->type == R_MIPS16_GOT16)
2507         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2508       else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2509         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2510
2511       /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
2512          carry or borrow will induce a change of +1 or -1 in the high part.  */
2513       hi->rel.addend += (vallo + 0x8000) & 0xffff;
2514
2515       ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2516                                          hi->input_section, output_bfd,
2517                                          error_message);
2518       if (ret != bfd_reloc_ok)
2519         return ret;
2520
2521       mips_hi16_list = hi->next;
2522       free (hi);
2523     }
2524
2525   return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2526                                       input_section, output_bfd,
2527                                       error_message);
2528 }
2529
2530 /* A generic howto special_function.  This calculates and installs the
2531    relocation itself, thus avoiding the oft-discussed problems in
2532    bfd_perform_relocation and bfd_install_relocation.  */
2533
2534 bfd_reloc_status_type
2535 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2536                              asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2537                              asection *input_section, bfd *output_bfd,
2538                              char **error_message ATTRIBUTE_UNUSED)
2539 {
2540   bfd_signed_vma val;
2541   bfd_reloc_status_type status;
2542   bfd_boolean relocatable;
2543
2544   relocatable = (output_bfd != NULL);
2545
2546   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2547     return bfd_reloc_outofrange;
2548
2549   /* Build up the field adjustment in VAL.  */
2550   val = 0;
2551   if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2552     {
2553       /* Either we're calculating the final field value or we have a
2554          relocation against a section symbol.  Add in the section's
2555          offset or address.  */
2556       val += symbol->section->output_section->vma;
2557       val += symbol->section->output_offset;
2558     }
2559
2560   if (!relocatable)
2561     {
2562       /* We're calculating the final field value.  Add in the symbol's value
2563          and, if pc-relative, subtract the address of the field itself.  */
2564       val += symbol->value;
2565       if (reloc_entry->howto->pc_relative)
2566         {
2567           val -= input_section->output_section->vma;
2568           val -= input_section->output_offset;
2569           val -= reloc_entry->address;
2570         }
2571     }
2572
2573   /* VAL is now the final adjustment.  If we're keeping this relocation
2574      in the output file, and if the relocation uses a separate addend,
2575      we just need to add VAL to that addend.  Otherwise we need to add
2576      VAL to the relocation field itself.  */
2577   if (relocatable && !reloc_entry->howto->partial_inplace)
2578     reloc_entry->addend += val;
2579   else
2580     {
2581       bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2582
2583       /* Add in the separate addend, if any.  */
2584       val += reloc_entry->addend;
2585
2586       /* Add VAL to the relocation field.  */
2587       _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2588                                      location);
2589       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2590                                        location);
2591       _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2592                                    location);
2593
2594       if (status != bfd_reloc_ok)
2595         return status;
2596     }
2597
2598   if (relocatable)
2599     reloc_entry->address += input_section->output_offset;
2600
2601   return bfd_reloc_ok;
2602 }
2603 \f
2604 /* Swap an entry in a .gptab section.  Note that these routines rely
2605    on the equivalence of the two elements of the union.  */
2606
2607 static void
2608 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2609                               Elf32_gptab *in)
2610 {
2611   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2612   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2613 }
2614
2615 static void
2616 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2617                                Elf32_External_gptab *ex)
2618 {
2619   H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2620   H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2621 }
2622
2623 static void
2624 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2625                                 Elf32_External_compact_rel *ex)
2626 {
2627   H_PUT_32 (abfd, in->id1, ex->id1);
2628   H_PUT_32 (abfd, in->num, ex->num);
2629   H_PUT_32 (abfd, in->id2, ex->id2);
2630   H_PUT_32 (abfd, in->offset, ex->offset);
2631   H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2632   H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2633 }
2634
2635 static void
2636 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2637                            Elf32_External_crinfo *ex)
2638 {
2639   unsigned long l;
2640
2641   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2642        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2643        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2644        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2645   H_PUT_32 (abfd, l, ex->info);
2646   H_PUT_32 (abfd, in->konst, ex->konst);
2647   H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2648 }
2649 \f
2650 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
2651    routines swap this structure in and out.  They are used outside of
2652    BFD, so they are globally visible.  */
2653
2654 void
2655 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2656                                 Elf32_RegInfo *in)
2657 {
2658   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2659   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2660   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2661   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2662   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2663   in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2664 }
2665
2666 void
2667 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2668                                  Elf32_External_RegInfo *ex)
2669 {
2670   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2671   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2672   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2673   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2674   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2675   H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2676 }
2677
2678 /* In the 64 bit ABI, the .MIPS.options section holds register
2679    information in an Elf64_Reginfo structure.  These routines swap
2680    them in and out.  They are globally visible because they are used
2681    outside of BFD.  These routines are here so that gas can call them
2682    without worrying about whether the 64 bit ABI has been included.  */
2683
2684 void
2685 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2686                                 Elf64_Internal_RegInfo *in)
2687 {
2688   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2689   in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2690   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2691   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2692   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2693   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2694   in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2695 }
2696
2697 void
2698 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2699                                  Elf64_External_RegInfo *ex)
2700 {
2701   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2702   H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2703   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2704   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2705   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2706   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2707   H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2708 }
2709
2710 /* Swap in an options header.  */
2711
2712 void
2713 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2714                               Elf_Internal_Options *in)
2715 {
2716   in->kind = H_GET_8 (abfd, ex->kind);
2717   in->size = H_GET_8 (abfd, ex->size);
2718   in->section = H_GET_16 (abfd, ex->section);
2719   in->info = H_GET_32 (abfd, ex->info);
2720 }
2721
2722 /* Swap out an options header.  */
2723
2724 void
2725 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2726                                Elf_External_Options *ex)
2727 {
2728   H_PUT_8 (abfd, in->kind, ex->kind);
2729   H_PUT_8 (abfd, in->size, ex->size);
2730   H_PUT_16 (abfd, in->section, ex->section);
2731   H_PUT_32 (abfd, in->info, ex->info);
2732 }
2733
2734 /* Swap in an abiflags structure.  */
2735
2736 void
2737 bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd,
2738                                   const Elf_External_ABIFlags_v0 *ex,
2739                                   Elf_Internal_ABIFlags_v0 *in)
2740 {
2741   in->version = H_GET_16 (abfd, ex->version);
2742   in->isa_level = H_GET_8 (abfd, ex->isa_level);
2743   in->isa_rev = H_GET_8 (abfd, ex->isa_rev);
2744   in->gpr_size = H_GET_8 (abfd, ex->gpr_size);
2745   in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size);
2746   in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size);
2747   in->fp_abi = H_GET_8 (abfd, ex->fp_abi);
2748   in->isa_ext = H_GET_32 (abfd, ex->isa_ext);
2749   in->ases = H_GET_32 (abfd, ex->ases);
2750   in->flags1 = H_GET_32 (abfd, ex->flags1);
2751   in->flags2 = H_GET_32 (abfd, ex->flags2);
2752 }
2753
2754 /* Swap out an abiflags structure.  */
2755
2756 void
2757 bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd,
2758                                    const Elf_Internal_ABIFlags_v0 *in,
2759                                    Elf_External_ABIFlags_v0 *ex)
2760 {
2761   H_PUT_16 (abfd, in->version, ex->version);
2762   H_PUT_8 (abfd, in->isa_level, ex->isa_level);
2763   H_PUT_8 (abfd, in->isa_rev, ex->isa_rev);
2764   H_PUT_8 (abfd, in->gpr_size, ex->gpr_size);
2765   H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size);
2766   H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size);
2767   H_PUT_8 (abfd, in->fp_abi, ex->fp_abi);
2768   H_PUT_32 (abfd, in->isa_ext, ex->isa_ext);
2769   H_PUT_32 (abfd, in->ases, ex->ases);
2770   H_PUT_32 (abfd, in->flags1, ex->flags1);
2771   H_PUT_32 (abfd, in->flags2, ex->flags2);
2772 }
2773 \f
2774 /* This function is called via qsort() to sort the dynamic relocation
2775    entries by increasing r_symndx value.  */
2776
2777 static int
2778 sort_dynamic_relocs (const void *arg1, const void *arg2)
2779 {
2780   Elf_Internal_Rela int_reloc1;
2781   Elf_Internal_Rela int_reloc2;
2782   int diff;
2783
2784   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2785   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2786
2787   diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2788   if (diff != 0)
2789     return diff;
2790
2791   if (int_reloc1.r_offset < int_reloc2.r_offset)
2792     return -1;
2793   if (int_reloc1.r_offset > int_reloc2.r_offset)
2794     return 1;
2795   return 0;
2796 }
2797
2798 /* Like sort_dynamic_relocs, but used for elf64 relocations.  */
2799
2800 static int
2801 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2802                         const void *arg2 ATTRIBUTE_UNUSED)
2803 {
2804 #ifdef BFD64
2805   Elf_Internal_Rela int_reloc1[3];
2806   Elf_Internal_Rela int_reloc2[3];
2807
2808   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2809     (reldyn_sorting_bfd, arg1, int_reloc1);
2810   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2811     (reldyn_sorting_bfd, arg2, int_reloc2);
2812
2813   if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2814     return -1;
2815   if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2816     return 1;
2817
2818   if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2819     return -1;
2820   if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2821     return 1;
2822   return 0;
2823 #else
2824   abort ();
2825 #endif
2826 }
2827
2828
2829 /* This routine is used to write out ECOFF debugging external symbol
2830    information.  It is called via mips_elf_link_hash_traverse.  The
2831    ECOFF external symbol information must match the ELF external
2832    symbol information.  Unfortunately, at this point we don't know
2833    whether a symbol is required by reloc information, so the two
2834    tables may wind up being different.  We must sort out the external
2835    symbol information before we can set the final size of the .mdebug
2836    section, and we must set the size of the .mdebug section before we
2837    can relocate any sections, and we can't know which symbols are
2838    required by relocation until we relocate the sections.
2839    Fortunately, it is relatively unlikely that any symbol will be
2840    stripped but required by a reloc.  In particular, it can not happen
2841    when generating a final executable.  */
2842
2843 static bfd_boolean
2844 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2845 {
2846   struct extsym_info *einfo = data;
2847   bfd_boolean strip;
2848   asection *sec, *output_section;
2849
2850   if (h->root.indx == -2)
2851     strip = FALSE;
2852   else if ((h->root.def_dynamic
2853             || h->root.ref_dynamic
2854             || h->root.type == bfd_link_hash_new)
2855            && !h->root.def_regular
2856            && !h->root.ref_regular)
2857     strip = TRUE;
2858   else if (einfo->info->strip == strip_all
2859            || (einfo->info->strip == strip_some
2860                && bfd_hash_lookup (einfo->info->keep_hash,
2861                                    h->root.root.root.string,
2862                                    FALSE, FALSE) == NULL))
2863     strip = TRUE;
2864   else
2865     strip = FALSE;
2866
2867   if (strip)
2868     return TRUE;
2869
2870   if (h->esym.ifd == -2)
2871     {
2872       h->esym.jmptbl = 0;
2873       h->esym.cobol_main = 0;
2874       h->esym.weakext = 0;
2875       h->esym.reserved = 0;
2876       h->esym.ifd = ifdNil;
2877       h->esym.asym.value = 0;
2878       h->esym.asym.st = stGlobal;
2879
2880       if (h->root.root.type == bfd_link_hash_undefined
2881           || h->root.root.type == bfd_link_hash_undefweak)
2882         {
2883           const char *name;
2884
2885           /* Use undefined class.  Also, set class and type for some
2886              special symbols.  */
2887           name = h->root.root.root.string;
2888           if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2889               || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2890             {
2891               h->esym.asym.sc = scData;
2892               h->esym.asym.st = stLabel;
2893               h->esym.asym.value = 0;
2894             }
2895           else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2896             {
2897               h->esym.asym.sc = scAbs;
2898               h->esym.asym.st = stLabel;
2899               h->esym.asym.value =
2900                 mips_elf_hash_table (einfo->info)->procedure_count;
2901             }
2902           else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2903             {
2904               h->esym.asym.sc = scAbs;
2905               h->esym.asym.st = stLabel;
2906               h->esym.asym.value = elf_gp (einfo->abfd);
2907             }
2908           else
2909             h->esym.asym.sc = scUndefined;
2910         }
2911       else if (h->root.root.type != bfd_link_hash_defined
2912           && h->root.root.type != bfd_link_hash_defweak)
2913         h->esym.asym.sc = scAbs;
2914       else
2915         {
2916           const char *name;
2917
2918           sec = h->root.root.u.def.section;
2919           output_section = sec->output_section;
2920
2921           /* When making a shared library and symbol h is the one from
2922              the another shared library, OUTPUT_SECTION may be null.  */
2923           if (output_section == NULL)
2924             h->esym.asym.sc = scUndefined;
2925           else
2926             {
2927               name = bfd_section_name (output_section->owner, output_section);
2928
2929               if (strcmp (name, ".text") == 0)
2930                 h->esym.asym.sc = scText;
2931               else if (strcmp (name, ".data") == 0)
2932                 h->esym.asym.sc = scData;
2933               else if (strcmp (name, ".sdata") == 0)
2934                 h->esym.asym.sc = scSData;
2935               else if (strcmp (name, ".rodata") == 0
2936                        || strcmp (name, ".rdata") == 0)
2937                 h->esym.asym.sc = scRData;
2938               else if (strcmp (name, ".bss") == 0)
2939                 h->esym.asym.sc = scBss;
2940               else if (strcmp (name, ".sbss") == 0)
2941                 h->esym.asym.sc = scSBss;
2942               else if (strcmp (name, ".init") == 0)
2943                 h->esym.asym.sc = scInit;
2944               else if (strcmp (name, ".fini") == 0)
2945                 h->esym.asym.sc = scFini;
2946               else
2947                 h->esym.asym.sc = scAbs;
2948             }
2949         }
2950
2951       h->esym.asym.reserved = 0;
2952       h->esym.asym.index = indexNil;
2953     }
2954
2955   if (h->root.root.type == bfd_link_hash_common)
2956     h->esym.asym.value = h->root.root.u.c.size;
2957   else if (h->root.root.type == bfd_link_hash_defined
2958            || h->root.root.type == bfd_link_hash_defweak)
2959     {
2960       if (h->esym.asym.sc == scCommon)
2961         h->esym.asym.sc = scBss;
2962       else if (h->esym.asym.sc == scSCommon)
2963         h->esym.asym.sc = scSBss;
2964
2965       sec = h->root.root.u.def.section;
2966       output_section = sec->output_section;
2967       if (output_section != NULL)
2968         h->esym.asym.value = (h->root.root.u.def.value
2969                               + sec->output_offset
2970                               + output_section->vma);
2971       else
2972         h->esym.asym.value = 0;
2973     }
2974   else
2975     {
2976       struct mips_elf_link_hash_entry *hd = h;
2977
2978       while (hd->root.root.type == bfd_link_hash_indirect)
2979         hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2980
2981       if (hd->needs_lazy_stub)
2982         {
2983           BFD_ASSERT (hd->root.plt.plist != NULL);
2984           BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE);
2985           /* Set type and value for a symbol with a function stub.  */
2986           h->esym.asym.st = stProc;
2987           sec = hd->root.root.u.def.section;
2988           if (sec == NULL)
2989             h->esym.asym.value = 0;
2990           else
2991             {
2992               output_section = sec->output_section;
2993               if (output_section != NULL)
2994                 h->esym.asym.value = (hd->root.plt.plist->stub_offset
2995                                       + sec->output_offset
2996                                       + output_section->vma);
2997               else
2998                 h->esym.asym.value = 0;
2999             }
3000         }
3001     }
3002
3003   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
3004                                       h->root.root.root.string,
3005                                       &h->esym))
3006     {
3007       einfo->failed = TRUE;
3008       return FALSE;
3009     }
3010
3011   return TRUE;
3012 }
3013
3014 /* A comparison routine used to sort .gptab entries.  */
3015
3016 static int
3017 gptab_compare (const void *p1, const void *p2)
3018 {
3019   const Elf32_gptab *a1 = p1;
3020   const Elf32_gptab *a2 = p2;
3021
3022   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
3023 }
3024 \f
3025 /* Functions to manage the got entry hash table.  */
3026
3027 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
3028    hash number.  */
3029
3030 static INLINE hashval_t
3031 mips_elf_hash_bfd_vma (bfd_vma addr)
3032 {
3033 #ifdef BFD64
3034   return addr + (addr >> 32);
3035 #else
3036   return addr;
3037 #endif
3038 }
3039
3040 static hashval_t
3041 mips_elf_got_entry_hash (const void *entry_)
3042 {
3043   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
3044
3045   return (entry->symndx
3046           + ((entry->tls_type == GOT_TLS_LDM) << 18)
3047           + (entry->tls_type == GOT_TLS_LDM ? 0
3048              : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
3049              : entry->symndx >= 0 ? (entry->abfd->id
3050                                      + mips_elf_hash_bfd_vma (entry->d.addend))
3051              : entry->d.h->root.root.root.hash));
3052 }
3053
3054 static int
3055 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
3056 {
3057   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
3058   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
3059
3060   return (e1->symndx == e2->symndx
3061           && e1->tls_type == e2->tls_type
3062           && (e1->tls_type == GOT_TLS_LDM ? TRUE
3063               : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address
3064               : e1->symndx >= 0 ? (e1->abfd == e2->abfd
3065                                    && e1->d.addend == e2->d.addend)
3066               : e2->abfd && e1->d.h == e2->d.h));
3067 }
3068
3069 static hashval_t
3070 mips_got_page_ref_hash (const void *ref_)
3071 {
3072   const struct mips_got_page_ref *ref;
3073
3074   ref = (const struct mips_got_page_ref *) ref_;
3075   return ((ref->symndx >= 0
3076            ? (hashval_t) (ref->u.abfd->id + ref->symndx)
3077            : ref->u.h->root.root.root.hash)
3078           + mips_elf_hash_bfd_vma (ref->addend));
3079 }
3080
3081 static int
3082 mips_got_page_ref_eq (const void *ref1_, const void *ref2_)
3083 {
3084   const struct mips_got_page_ref *ref1, *ref2;
3085
3086   ref1 = (const struct mips_got_page_ref *) ref1_;
3087   ref2 = (const struct mips_got_page_ref *) ref2_;
3088   return (ref1->symndx == ref2->symndx
3089           && (ref1->symndx < 0
3090               ? ref1->u.h == ref2->u.h
3091               : ref1->u.abfd == ref2->u.abfd)
3092           && ref1->addend == ref2->addend);
3093 }
3094
3095 static hashval_t
3096 mips_got_page_entry_hash (const void *entry_)
3097 {
3098   const struct mips_got_page_entry *entry;
3099
3100   entry = (const struct mips_got_page_entry *) entry_;
3101   return entry->sec->id;
3102 }
3103
3104 static int
3105 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
3106 {
3107   const struct mips_got_page_entry *entry1, *entry2;
3108
3109   entry1 = (const struct mips_got_page_entry *) entry1_;
3110   entry2 = (const struct mips_got_page_entry *) entry2_;
3111   return entry1->sec == entry2->sec;
3112 }
3113 \f
3114 /* Create and return a new mips_got_info structure.  */
3115
3116 static struct mips_got_info *
3117 mips_elf_create_got_info (bfd *abfd)
3118 {
3119   struct mips_got_info *g;
3120
3121   g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
3122   if (g == NULL)
3123     return NULL;
3124
3125   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
3126                                     mips_elf_got_entry_eq, NULL);
3127   if (g->got_entries == NULL)
3128     return NULL;
3129
3130   g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash,
3131                                       mips_got_page_ref_eq, NULL);
3132   if (g->got_page_refs == NULL)
3133     return NULL;
3134
3135   return g;
3136 }
3137
3138 /* Return the GOT info for input bfd ABFD, trying to create a new one if
3139    CREATE_P and if ABFD doesn't already have a GOT.  */
3140
3141 static struct mips_got_info *
3142 mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p)
3143 {
3144   struct mips_elf_obj_tdata *tdata;
3145
3146   if (!is_mips_elf (abfd))
3147     return NULL;
3148
3149   tdata = mips_elf_tdata (abfd);
3150   if (!tdata->got && create_p)
3151     tdata->got = mips_elf_create_got_info (abfd);
3152   return tdata->got;
3153 }
3154
3155 /* Record that ABFD should use output GOT G.  */
3156
3157 static void
3158 mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g)
3159 {
3160   struct mips_elf_obj_tdata *tdata;
3161
3162   BFD_ASSERT (is_mips_elf (abfd));
3163   tdata = mips_elf_tdata (abfd);
3164   if (tdata->got)
3165     {
3166       /* The GOT structure itself and the hash table entries are
3167          allocated to a bfd, but the hash tables aren't.  */
3168       htab_delete (tdata->got->got_entries);
3169       htab_delete (tdata->got->got_page_refs);
3170       if (tdata->got->got_page_entries)
3171         htab_delete (tdata->got->got_page_entries);
3172     }
3173   tdata->got = g;
3174 }
3175
3176 /* Return the dynamic relocation section.  If it doesn't exist, try to
3177    create a new it if CREATE_P, otherwise return NULL.  Also return NULL
3178    if creation fails.  */
3179
3180 static asection *
3181 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
3182 {
3183   const char *dname;
3184   asection *sreloc;
3185   bfd *dynobj;
3186
3187   dname = MIPS_ELF_REL_DYN_NAME (info);
3188   dynobj = elf_hash_table (info)->dynobj;
3189   sreloc = bfd_get_linker_section (dynobj, dname);
3190   if (sreloc == NULL && create_p)
3191     {
3192       sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
3193                                                    (SEC_ALLOC
3194                                                     | SEC_LOAD
3195                                                     | SEC_HAS_CONTENTS
3196                                                     | SEC_IN_MEMORY
3197                                                     | SEC_LINKER_CREATED
3198                                                     | SEC_READONLY));
3199       if (sreloc == NULL
3200           || ! bfd_set_section_alignment (dynobj, sreloc,
3201                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
3202         return NULL;
3203     }
3204   return sreloc;
3205 }
3206
3207 /* Return the GOT_TLS_* type required by relocation type R_TYPE.  */
3208
3209 static int
3210 mips_elf_reloc_tls_type (unsigned int r_type)
3211 {
3212   if (tls_gd_reloc_p (r_type))
3213     return GOT_TLS_GD;
3214
3215   if (tls_ldm_reloc_p (r_type))
3216     return GOT_TLS_LDM;
3217
3218   if (tls_gottprel_reloc_p (r_type))
3219     return GOT_TLS_IE;
3220
3221   return GOT_TLS_NONE;
3222 }
3223
3224 /* Return the number of GOT slots needed for GOT TLS type TYPE.  */
3225
3226 static int
3227 mips_tls_got_entries (unsigned int type)
3228 {
3229   switch (type)
3230     {
3231     case GOT_TLS_GD:
3232     case GOT_TLS_LDM:
3233       return 2;
3234
3235     case GOT_TLS_IE:
3236       return 1;
3237
3238     case GOT_TLS_NONE:
3239       return 0;
3240     }
3241   abort ();
3242 }
3243
3244 /* Count the number of relocations needed for a TLS GOT entry, with
3245    access types from TLS_TYPE, and symbol H (or a local symbol if H
3246    is NULL).  */
3247
3248 static int
3249 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
3250                      struct elf_link_hash_entry *h)
3251 {
3252   int indx = 0;
3253   bfd_boolean need_relocs = FALSE;
3254   bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3255
3256   if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
3257       && (!bfd_link_pic (info) || !SYMBOL_REFERENCES_LOCAL (info, h)))
3258     indx = h->dynindx;
3259
3260   if ((bfd_link_pic (info) || indx != 0)
3261       && (h == NULL
3262           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3263           || h->root.type != bfd_link_hash_undefweak))
3264     need_relocs = TRUE;
3265
3266   if (!need_relocs)
3267     return 0;
3268
3269   switch (tls_type)
3270     {
3271     case GOT_TLS_GD:
3272       return indx != 0 ? 2 : 1;
3273
3274     case GOT_TLS_IE:
3275       return 1;
3276
3277     case GOT_TLS_LDM:
3278       return bfd_link_pic (info) ? 1 : 0;
3279
3280     default:
3281       return 0;
3282     }
3283 }
3284
3285 /* Add the number of GOT entries and TLS relocations required by ENTRY
3286    to G.  */
3287
3288 static void
3289 mips_elf_count_got_entry (struct bfd_link_info *info,
3290                           struct mips_got_info *g,
3291                           struct mips_got_entry *entry)
3292 {
3293   if (entry->tls_type)
3294     {
3295       g->tls_gotno += mips_tls_got_entries (entry->tls_type);
3296       g->relocs += mips_tls_got_relocs (info, entry->tls_type,
3297                                         entry->symndx < 0
3298                                         ? &entry->d.h->root : NULL);
3299     }
3300   else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
3301     g->local_gotno += 1;
3302   else
3303     g->global_gotno += 1;
3304 }
3305
3306 /* Output a simple dynamic relocation into SRELOC.  */
3307
3308 static void
3309 mips_elf_output_dynamic_relocation (bfd *output_bfd,
3310                                     asection *sreloc,
3311                                     unsigned long reloc_index,
3312                                     unsigned long indx,
3313                                     int r_type,
3314                                     bfd_vma offset)
3315 {
3316   Elf_Internal_Rela rel[3];
3317
3318   memset (rel, 0, sizeof (rel));
3319
3320   rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3321   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3322
3323   if (ABI_64_P (output_bfd))
3324     {
3325       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3326         (output_bfd, &rel[0],
3327          (sreloc->contents
3328           + reloc_index * sizeof (Elf64_Mips_External_Rel)));
3329     }
3330   else
3331     bfd_elf32_swap_reloc_out
3332       (output_bfd, &rel[0],
3333        (sreloc->contents
3334         + reloc_index * sizeof (Elf32_External_Rel)));
3335 }
3336
3337 /* Initialize a set of TLS GOT entries for one symbol.  */
3338
3339 static void
3340 mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info,
3341                                struct mips_got_entry *entry,
3342                                struct mips_elf_link_hash_entry *h,
3343                                bfd_vma value)
3344 {
3345   struct mips_elf_link_hash_table *htab;
3346   int indx;
3347   asection *sreloc, *sgot;
3348   bfd_vma got_offset, got_offset2;
3349   bfd_boolean need_relocs = FALSE;
3350
3351   htab = mips_elf_hash_table (info);
3352   if (htab == NULL)
3353     return;
3354
3355   sgot = htab->root.sgot;
3356
3357   indx = 0;
3358   if (h != NULL)
3359     {
3360       bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3361
3362       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
3363                                            &h->root)
3364           && (!bfd_link_pic (info)
3365               || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3366         indx = h->root.dynindx;
3367     }
3368
3369   if (entry->tls_initialized)
3370     return;
3371
3372   if ((bfd_link_pic (info) || indx != 0)
3373       && (h == NULL
3374           || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3375           || h->root.type != bfd_link_hash_undefweak))
3376     need_relocs = TRUE;
3377
3378   /* MINUS_ONE means the symbol is not defined in this object.  It may not
3379      be defined at all; assume that the value doesn't matter in that
3380      case.  Otherwise complain if we would use the value.  */
3381   BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3382               || h->root.root.type == bfd_link_hash_undefweak);
3383
3384   /* Emit necessary relocations.  */
3385   sreloc = mips_elf_rel_dyn_section (info, FALSE);
3386   got_offset = entry->gotidx;
3387
3388   switch (entry->tls_type)
3389     {
3390     case GOT_TLS_GD:
3391       /* General Dynamic.  */
3392       got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd);
3393
3394       if (need_relocs)
3395         {
3396           mips_elf_output_dynamic_relocation
3397             (abfd, sreloc, sreloc->reloc_count++, indx,
3398              ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3399              sgot->output_offset + sgot->output_section->vma + got_offset);
3400
3401           if (indx)
3402             mips_elf_output_dynamic_relocation
3403               (abfd, sreloc, sreloc->reloc_count++, indx,
3404                ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3405                sgot->output_offset + sgot->output_section->vma + got_offset2);
3406           else
3407             MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3408                                sgot->contents + got_offset2);
3409         }
3410       else
3411         {
3412           MIPS_ELF_PUT_WORD (abfd, 1,
3413                              sgot->contents + got_offset);
3414           MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3415                              sgot->contents + got_offset2);
3416         }
3417       break;
3418
3419     case GOT_TLS_IE:
3420       /* Initial Exec model.  */
3421       if (need_relocs)
3422         {
3423           if (indx == 0)
3424             MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3425                                sgot->contents + got_offset);
3426           else
3427             MIPS_ELF_PUT_WORD (abfd, 0,
3428                                sgot->contents + got_offset);
3429
3430           mips_elf_output_dynamic_relocation
3431             (abfd, sreloc, sreloc->reloc_count++, indx,
3432              ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3433              sgot->output_offset + sgot->output_section->vma + got_offset);
3434         }
3435       else
3436         MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3437                            sgot->contents + got_offset);
3438       break;
3439
3440     case GOT_TLS_LDM:
3441       /* The initial offset is zero, and the LD offsets will include the
3442          bias by DTP_OFFSET.  */
3443       MIPS_ELF_PUT_WORD (abfd, 0,
3444                          sgot->contents + got_offset
3445                          + MIPS_ELF_GOT_SIZE (abfd));
3446
3447       if (!bfd_link_pic (info))
3448         MIPS_ELF_PUT_WORD (abfd, 1,
3449                            sgot->contents + got_offset);
3450       else
3451         mips_elf_output_dynamic_relocation
3452           (abfd, sreloc, sreloc->reloc_count++, indx,
3453            ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3454            sgot->output_offset + sgot->output_section->vma + got_offset);
3455       break;
3456
3457     default:
3458       abort ();
3459     }
3460
3461   entry->tls_initialized = TRUE;
3462 }
3463
3464 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3465    for global symbol H.  .got.plt comes before the GOT, so the offset
3466    will be negative.  */
3467
3468 static bfd_vma
3469 mips_elf_gotplt_index (struct bfd_link_info *info,
3470                        struct elf_link_hash_entry *h)
3471 {
3472   bfd_vma got_address, got_value;
3473   struct mips_elf_link_hash_table *htab;
3474
3475   htab = mips_elf_hash_table (info);
3476   BFD_ASSERT (htab != NULL);
3477
3478   BFD_ASSERT (h->plt.plist != NULL);
3479   BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE);
3480
3481   /* Calculate the address of the associated .got.plt entry.  */
3482   got_address = (htab->root.sgotplt->output_section->vma
3483                  + htab->root.sgotplt->output_offset
3484                  + (h->plt.plist->gotplt_index
3485                     * MIPS_ELF_GOT_SIZE (info->output_bfd)));
3486
3487   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
3488   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3489                + htab->root.hgot->root.u.def.section->output_offset
3490                + htab->root.hgot->root.u.def.value);
3491
3492   return got_address - got_value;
3493 }
3494
3495 /* Return the GOT offset for address VALUE.   If there is not yet a GOT
3496    entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
3497    create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
3498    offset can be found.  */
3499
3500 static bfd_vma
3501 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3502                           bfd_vma value, unsigned long r_symndx,
3503                           struct mips_elf_link_hash_entry *h, int r_type)
3504 {
3505   struct mips_elf_link_hash_table *htab;
3506   struct mips_got_entry *entry;
3507
3508   htab = mips_elf_hash_table (info);
3509   BFD_ASSERT (htab != NULL);
3510
3511   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3512                                            r_symndx, h, r_type);
3513   if (!entry)
3514     return MINUS_ONE;
3515
3516   if (entry->tls_type)
3517     mips_elf_initialize_tls_slots (abfd, info, entry, h, value);
3518   return entry->gotidx;
3519 }
3520
3521 /* Return the GOT index of global symbol H in the primary GOT.  */
3522
3523 static bfd_vma
3524 mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info,
3525                                    struct elf_link_hash_entry *h)
3526 {
3527   struct mips_elf_link_hash_table *htab;
3528   long global_got_dynindx;
3529   struct mips_got_info *g;
3530   bfd_vma got_index;
3531
3532   htab = mips_elf_hash_table (info);
3533   BFD_ASSERT (htab != NULL);
3534
3535   global_got_dynindx = 0;
3536   if (htab->global_gotsym != NULL)
3537     global_got_dynindx = htab->global_gotsym->dynindx;
3538
3539   /* Once we determine the global GOT entry with the lowest dynamic
3540      symbol table index, we must put all dynamic symbols with greater
3541      indices into the primary GOT.  That makes it easy to calculate the
3542      GOT offset.  */
3543   BFD_ASSERT (h->dynindx >= global_got_dynindx);
3544   g = mips_elf_bfd_got (obfd, FALSE);
3545   got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3546                * MIPS_ELF_GOT_SIZE (obfd));
3547   BFD_ASSERT (got_index < htab->root.sgot->size);
3548
3549   return got_index;
3550 }
3551
3552 /* Return the GOT index for the global symbol indicated by H, which is
3553    referenced by a relocation of type R_TYPE in IBFD.  */
3554
3555 static bfd_vma
3556 mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd,
3557                            struct elf_link_hash_entry *h, int r_type)
3558 {
3559   struct mips_elf_link_hash_table *htab;
3560   struct mips_got_info *g;
3561   struct mips_got_entry lookup, *entry;
3562   bfd_vma gotidx;
3563
3564   htab = mips_elf_hash_table (info);
3565   BFD_ASSERT (htab != NULL);
3566
3567   g = mips_elf_bfd_got (ibfd, FALSE);
3568   BFD_ASSERT (g);
3569
3570   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3571   if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE))
3572     return mips_elf_primary_global_got_index (obfd, info, h);
3573
3574   lookup.abfd = ibfd;
3575   lookup.symndx = -1;
3576   lookup.d.h = (struct mips_elf_link_hash_entry *) h;
3577   entry = htab_find (g->got_entries, &lookup);
3578   BFD_ASSERT (entry);
3579
3580   gotidx = entry->gotidx;
3581   BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3582
3583   if (lookup.tls_type)
3584     {
3585       bfd_vma value = MINUS_ONE;
3586
3587       if ((h->root.type == bfd_link_hash_defined
3588            || h->root.type == bfd_link_hash_defweak)
3589           && h->root.u.def.section->output_section)
3590         value = (h->root.u.def.value
3591                  + h->root.u.def.section->output_offset
3592                  + h->root.u.def.section->output_section->vma);
3593
3594       mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value);
3595     }
3596   return gotidx;
3597 }
3598
3599 /* Find a GOT page entry that points to within 32KB of VALUE.  These
3600    entries are supposed to be placed at small offsets in the GOT, i.e.,
3601    within 32KB of GP.  Return the index of the GOT entry, or -1 if no
3602    entry could be created.  If OFFSETP is nonnull, use it to return the
3603    offset of the GOT entry from VALUE.  */
3604
3605 static bfd_vma
3606 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3607                    bfd_vma value, bfd_vma *offsetp)
3608 {
3609   bfd_vma page, got_index;
3610   struct mips_got_entry *entry;
3611
3612   page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3613   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3614                                            NULL, R_MIPS_GOT_PAGE);
3615
3616   if (!entry)
3617     return MINUS_ONE;
3618
3619   got_index = entry->gotidx;
3620
3621   if (offsetp)
3622     *offsetp = value - entry->d.address;
3623
3624   return got_index;
3625 }
3626
3627 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3628    EXTERNAL is true if the relocation was originally against a global
3629    symbol that binds locally.  */
3630
3631 static bfd_vma
3632 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3633                       bfd_vma value, bfd_boolean external)
3634 {
3635   struct mips_got_entry *entry;
3636
3637   /* GOT16 relocations against local symbols are followed by a LO16
3638      relocation; those against global symbols are not.  Thus if the
3639      symbol was originally local, the GOT16 relocation should load the
3640      equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
3641   if (! external)
3642     value = mips_elf_high (value) << 16;
3643
3644   /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3645      R_MIPS16_GOT16, R_MIPS_CALL16, etc.  The format of the entry is the
3646      same in all cases.  */
3647   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3648                                            NULL, R_MIPS_GOT16);
3649   if (entry)
3650     return entry->gotidx;
3651   else
3652     return MINUS_ONE;
3653 }
3654
3655 /* Returns the offset for the entry at the INDEXth position
3656    in the GOT.  */
3657
3658 static bfd_vma
3659 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3660                                 bfd *input_bfd, bfd_vma got_index)
3661 {
3662   struct mips_elf_link_hash_table *htab;
3663   asection *sgot;
3664   bfd_vma gp;
3665
3666   htab = mips_elf_hash_table (info);
3667   BFD_ASSERT (htab != NULL);
3668
3669   sgot = htab->root.sgot;
3670   gp = _bfd_get_gp_value (output_bfd)
3671     + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3672
3673   return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3674 }
3675
3676 /* Create and return a local GOT entry for VALUE, which was calculated
3677    from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
3678    be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
3679    instead.  */
3680
3681 static struct mips_got_entry *
3682 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3683                                  bfd *ibfd, bfd_vma value,
3684                                  unsigned long r_symndx,
3685                                  struct mips_elf_link_hash_entry *h,
3686                                  int r_type)
3687 {
3688   struct mips_got_entry lookup, *entry;
3689   void **loc;
3690   struct mips_got_info *g;
3691   struct mips_elf_link_hash_table *htab;
3692   bfd_vma gotidx;
3693
3694   htab = mips_elf_hash_table (info);
3695   BFD_ASSERT (htab != NULL);
3696
3697   g = mips_elf_bfd_got (ibfd, FALSE);
3698   if (g == NULL)
3699     {
3700       g = mips_elf_bfd_got (abfd, FALSE);
3701       BFD_ASSERT (g != NULL);
3702     }
3703
3704   /* This function shouldn't be called for symbols that live in the global
3705      area of the GOT.  */
3706   BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3707
3708   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3709   if (lookup.tls_type)
3710     {
3711       lookup.abfd = ibfd;
3712       if (tls_ldm_reloc_p (r_type))
3713         {
3714           lookup.symndx = 0;
3715           lookup.d.addend = 0;
3716         }
3717       else if (h == NULL)
3718         {
3719           lookup.symndx = r_symndx;
3720           lookup.d.addend = 0;
3721         }
3722       else
3723         {
3724           lookup.symndx = -1;
3725           lookup.d.h = h;
3726         }
3727
3728       entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup);
3729       BFD_ASSERT (entry);
3730
3731       gotidx = entry->gotidx;
3732       BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3733
3734       return entry;
3735     }
3736
3737   lookup.abfd = NULL;
3738   lookup.symndx = -1;
3739   lookup.d.address = value;
3740   loc = htab_find_slot (g->got_entries, &lookup, INSERT);
3741   if (!loc)
3742     return NULL;
3743
3744   entry = (struct mips_got_entry *) *loc;
3745   if (entry)
3746     return entry;
3747
3748   if (g->assigned_low_gotno > g->assigned_high_gotno)
3749     {
3750       /* We didn't allocate enough space in the GOT.  */
3751       _bfd_error_handler
3752         (_("not enough GOT space for local GOT entries"));
3753       bfd_set_error (bfd_error_bad_value);
3754       return NULL;
3755     }
3756
3757   entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3758   if (!entry)
3759     return NULL;
3760
3761   if (got16_reloc_p (r_type)
3762       || call16_reloc_p (r_type)
3763       || got_page_reloc_p (r_type)
3764       || got_disp_reloc_p (r_type))
3765     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++;
3766   else
3767     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--;
3768
3769   *entry = lookup;
3770   *loc = entry;
3771
3772   MIPS_ELF_PUT_WORD (abfd, value, htab->root.sgot->contents + entry->gotidx);
3773
3774   /* These GOT entries need a dynamic relocation on VxWorks.  */
3775   if (htab->is_vxworks)
3776     {
3777       Elf_Internal_Rela outrel;
3778       asection *s;
3779       bfd_byte *rloc;
3780       bfd_vma got_address;
3781
3782       s = mips_elf_rel_dyn_section (info, FALSE);
3783       got_address = (htab->root.sgot->output_section->vma
3784                      + htab->root.sgot->output_offset
3785                      + entry->gotidx);
3786
3787       rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3788       outrel.r_offset = got_address;
3789       outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3790       outrel.r_addend = value;
3791       bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3792     }
3793
3794   return entry;
3795 }
3796
3797 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3798    The number might be exact or a worst-case estimate, depending on how
3799    much information is available to elf_backend_omit_section_dynsym at
3800    the current linking stage.  */
3801
3802 static bfd_size_type
3803 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3804 {
3805   bfd_size_type count;
3806
3807   count = 0;
3808   if (bfd_link_pic (info)
3809       || elf_hash_table (info)->is_relocatable_executable)
3810     {
3811       asection *p;
3812       const struct elf_backend_data *bed;
3813
3814       bed = get_elf_backend_data (output_bfd);
3815       for (p = output_bfd->sections; p ; p = p->next)
3816         if ((p->flags & SEC_EXCLUDE) == 0
3817             && (p->flags & SEC_ALLOC) != 0
3818             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3819           ++count;
3820     }
3821   return count;
3822 }
3823
3824 /* Sort the dynamic symbol table so that symbols that need GOT entries
3825    appear towards the end.  */
3826
3827 static bfd_boolean
3828 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3829 {
3830   struct mips_elf_link_hash_table *htab;
3831   struct mips_elf_hash_sort_data hsd;
3832   struct mips_got_info *g;
3833
3834   if (elf_hash_table (info)->dynsymcount == 0)
3835     return TRUE;
3836
3837   htab = mips_elf_hash_table (info);
3838   BFD_ASSERT (htab != NULL);
3839
3840   g = htab->got_info;
3841   if (g == NULL)
3842     return TRUE;
3843
3844   hsd.low = NULL;
3845   hsd.max_unref_got_dynindx
3846     = hsd.min_got_dynindx
3847     = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
3848   hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
3849   mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3850                                 elf_hash_table (info)),
3851                                mips_elf_sort_hash_table_f,
3852                                &hsd);
3853
3854   /* There should have been enough room in the symbol table to
3855      accommodate both the GOT and non-GOT symbols.  */
3856   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3857   BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3858               == elf_hash_table (info)->dynsymcount);
3859   BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3860               == g->global_gotno);
3861
3862   /* Now we know which dynamic symbol has the lowest dynamic symbol
3863      table index in the GOT.  */
3864   htab->global_gotsym = hsd.low;
3865
3866   return TRUE;
3867 }
3868
3869 /* If H needs a GOT entry, assign it the highest available dynamic
3870    index.  Otherwise, assign it the lowest available dynamic
3871    index.  */
3872
3873 static bfd_boolean
3874 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3875 {
3876   struct mips_elf_hash_sort_data *hsd = data;
3877
3878   /* Symbols without dynamic symbol table entries aren't interesting
3879      at all.  */
3880   if (h->root.dynindx == -1)
3881     return TRUE;
3882
3883   switch (h->global_got_area)
3884     {
3885     case GGA_NONE:
3886       h->root.dynindx = hsd->max_non_got_dynindx++;
3887       break;
3888
3889     case GGA_NORMAL:
3890       h->root.dynindx = --hsd->min_got_dynindx;
3891       hsd->low = (struct elf_link_hash_entry *) h;
3892       break;
3893
3894     case GGA_RELOC_ONLY:
3895       if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3896         hsd->low = (struct elf_link_hash_entry *) h;
3897       h->root.dynindx = hsd->max_unref_got_dynindx++;
3898       break;
3899     }
3900
3901   return TRUE;
3902 }
3903
3904 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3905    (which is owned by the caller and shouldn't be added to the
3906    hash table directly).  */
3907
3908 static bfd_boolean
3909 mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd,
3910                            struct mips_got_entry *lookup)
3911 {
3912   struct mips_elf_link_hash_table *htab;
3913   struct mips_got_entry *entry;
3914   struct mips_got_info *g;
3915   void **loc, **bfd_loc;
3916
3917   /* Make sure there's a slot for this entry in the master GOT.  */
3918   htab = mips_elf_hash_table (info);
3919   g = htab->got_info;
3920   loc = htab_find_slot (g->got_entries, lookup, INSERT);
3921   if (!loc)
3922     return FALSE;
3923
3924   /* Populate the entry if it isn't already.  */
3925   entry = (struct mips_got_entry *) *loc;
3926   if (!entry)
3927     {
3928       entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3929       if (!entry)
3930         return FALSE;
3931
3932       lookup->tls_initialized = FALSE;
3933       lookup->gotidx = -1;
3934       *entry = *lookup;
3935       *loc = entry;
3936     }
3937
3938   /* Reuse the same GOT entry for the BFD's GOT.  */
3939   g = mips_elf_bfd_got (abfd, TRUE);
3940   if (!g)
3941     return FALSE;
3942
3943   bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT);
3944   if (!bfd_loc)
3945     return FALSE;
3946
3947   if (!*bfd_loc)
3948     *bfd_loc = entry;
3949   return TRUE;
3950 }
3951
3952 /* ABFD has a GOT relocation of type R_TYPE against H.  Reserve a GOT
3953    entry for it.  FOR_CALL is true if the caller is only interested in
3954    using the GOT entry for calls.  */
3955
3956 static bfd_boolean
3957 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3958                                    bfd *abfd, struct bfd_link_info *info,
3959                                    bfd_boolean for_call, int r_type)
3960 {
3961   struct mips_elf_link_hash_table *htab;
3962   struct mips_elf_link_hash_entry *hmips;
3963   struct mips_got_entry entry;
3964   unsigned char tls_type;
3965
3966   htab = mips_elf_hash_table (info);
3967   BFD_ASSERT (htab != NULL);
3968
3969   hmips = (struct mips_elf_link_hash_entry *) h;
3970   if (!for_call)
3971     hmips->got_only_for_calls = FALSE;
3972
3973   /* A global symbol in the GOT must also be in the dynamic symbol
3974      table.  */
3975   if (h->dynindx == -1)
3976     {
3977       switch (ELF_ST_VISIBILITY (h->other))
3978         {
3979         case STV_INTERNAL:
3980         case STV_HIDDEN:
3981           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3982           break;
3983         }
3984       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3985         return FALSE;
3986     }
3987
3988   tls_type = mips_elf_reloc_tls_type (r_type);
3989   if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL)
3990     hmips->global_got_area = GGA_NORMAL;
3991
3992   entry.abfd = abfd;
3993   entry.symndx = -1;
3994   entry.d.h = (struct mips_elf_link_hash_entry *) h;
3995   entry.tls_type = tls_type;
3996   return mips_elf_record_got_entry (info, abfd, &entry);
3997 }
3998
3999 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
4000    where SYMNDX is a local symbol.  Reserve a GOT entry for it.  */
4001
4002 static bfd_boolean
4003 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
4004                                   struct bfd_link_info *info, int r_type)
4005 {
4006   struct mips_elf_link_hash_table *htab;
4007   struct mips_got_info *g;
4008   struct mips_got_entry entry;
4009
4010   htab = mips_elf_hash_table (info);
4011   BFD_ASSERT (htab != NULL);
4012
4013   g = htab->got_info;
4014   BFD_ASSERT (g != NULL);
4015
4016   entry.abfd = abfd;
4017   entry.symndx = symndx;
4018   entry.d.addend = addend;
4019   entry.tls_type = mips_elf_reloc_tls_type (r_type);
4020   return mips_elf_record_got_entry (info, abfd, &entry);
4021 }
4022
4023 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
4024    H is the symbol's hash table entry, or null if SYMNDX is local
4025    to ABFD.  */
4026
4027 static bfd_boolean
4028 mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd,
4029                               long symndx, struct elf_link_hash_entry *h,
4030                               bfd_signed_vma addend)
4031 {
4032   struct mips_elf_link_hash_table *htab;
4033   struct mips_got_info *g1, *g2;
4034   struct mips_got_page_ref lookup, *entry;
4035   void **loc, **bfd_loc;
4036
4037   htab = mips_elf_hash_table (info);
4038   BFD_ASSERT (htab != NULL);
4039
4040   g1 = htab->got_info;
4041   BFD_ASSERT (g1 != NULL);
4042
4043   if (h)
4044     {
4045       lookup.symndx = -1;
4046       lookup.u.h = (struct mips_elf_link_hash_entry *) h;
4047     }
4048   else
4049     {
4050       lookup.symndx = symndx;
4051       lookup.u.abfd = abfd;
4052     }
4053   lookup.addend = addend;
4054   loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT);
4055   if (loc == NULL)
4056     return FALSE;
4057
4058   entry = (struct mips_got_page_ref *) *loc;
4059   if (!entry)
4060     {
4061       entry = bfd_alloc (abfd, sizeof (*entry));
4062       if (!entry)
4063         return FALSE;
4064
4065       *entry = lookup;
4066       *loc = entry;
4067     }
4068
4069   /* Add the same entry to the BFD's GOT.  */
4070   g2 = mips_elf_bfd_got (abfd, TRUE);
4071   if (!g2)
4072     return FALSE;
4073
4074   bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT);
4075   if (!bfd_loc)
4076     return FALSE;
4077
4078   if (!*bfd_loc)
4079     *bfd_loc = entry;
4080
4081   return TRUE;
4082 }
4083
4084 /* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
4085
4086 static void
4087 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
4088                                        unsigned int n)
4089 {
4090   asection *s;
4091   struct mips_elf_link_hash_table *htab;
4092
4093   htab = mips_elf_hash_table (info);
4094   BFD_ASSERT (htab != NULL);
4095
4096   s = mips_elf_rel_dyn_section (info, FALSE);
4097   BFD_ASSERT (s != NULL);
4098
4099   if (htab->is_vxworks)
4100     s->size += n * MIPS_ELF_RELA_SIZE (abfd);
4101   else
4102     {
4103       if (s->size == 0)
4104         {
4105           /* Make room for a null element.  */
4106           s->size += MIPS_ELF_REL_SIZE (abfd);
4107           ++s->reloc_count;
4108         }
4109       s->size += n * MIPS_ELF_REL_SIZE (abfd);
4110     }
4111 }
4112 \f
4113 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4114    mips_elf_traverse_got_arg structure.  Count the number of GOT
4115    entries and TLS relocs.  Set DATA->value to true if we need
4116    to resolve indirect or warning symbols and then recreate the GOT.  */
4117
4118 static int
4119 mips_elf_check_recreate_got (void **entryp, void *data)
4120 {
4121   struct mips_got_entry *entry;
4122   struct mips_elf_traverse_got_arg *arg;
4123
4124   entry = (struct mips_got_entry *) *entryp;
4125   arg = (struct mips_elf_traverse_got_arg *) data;
4126   if (entry->abfd != NULL && entry->symndx == -1)
4127     {
4128       struct mips_elf_link_hash_entry *h;
4129
4130       h = entry->d.h;
4131       if (h->root.root.type == bfd_link_hash_indirect
4132           || h->root.root.type == bfd_link_hash_warning)
4133         {
4134           arg->value = TRUE;
4135           return 0;
4136         }
4137     }
4138   mips_elf_count_got_entry (arg->info, arg->g, entry);
4139   return 1;
4140 }
4141
4142 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4143    mips_elf_traverse_got_arg structure.  Add all entries to DATA->g,
4144    converting entries for indirect and warning symbols into entries
4145    for the target symbol.  Set DATA->g to null on error.  */
4146
4147 static int
4148 mips_elf_recreate_got (void **entryp, void *data)
4149 {
4150   struct mips_got_entry new_entry, *entry;
4151   struct mips_elf_traverse_got_arg *arg;
4152   void **slot;
4153
4154   entry = (struct mips_got_entry *) *entryp;
4155   arg = (struct mips_elf_traverse_got_arg *) data;
4156   if (entry->abfd != NULL
4157       && entry->symndx == -1
4158       && (entry->d.h->root.root.type == bfd_link_hash_indirect
4159           || entry->d.h->root.root.type == bfd_link_hash_warning))
4160     {
4161       struct mips_elf_link_hash_entry *h;
4162
4163       new_entry = *entry;
4164       entry = &new_entry;
4165       h = entry->d.h;
4166       do
4167         {
4168           BFD_ASSERT (h->global_got_area == GGA_NONE);
4169           h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4170         }
4171       while (h->root.root.type == bfd_link_hash_indirect
4172              || h->root.root.type == bfd_link_hash_warning);
4173       entry->d.h = h;
4174     }
4175   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4176   if (slot == NULL)
4177     {
4178       arg->g = NULL;
4179       return 0;
4180     }
4181   if (*slot == NULL)
4182     {
4183       if (entry == &new_entry)
4184         {
4185           entry = bfd_alloc (entry->abfd, sizeof (*entry));
4186           if (!entry)
4187             {
4188               arg->g = NULL;
4189               return 0;
4190             }
4191           *entry = new_entry;
4192         }
4193       *slot = entry;
4194       mips_elf_count_got_entry (arg->info, arg->g, entry);
4195     }
4196   return 1;
4197 }
4198
4199 /* Return the maximum number of GOT page entries required for RANGE.  */
4200
4201 static bfd_vma
4202 mips_elf_pages_for_range (const struct mips_got_page_range *range)
4203 {
4204   return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
4205 }
4206
4207 /* Record that G requires a page entry that can reach SEC + ADDEND.  */
4208
4209 static bfd_boolean
4210 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg,
4211                                 asection *sec, bfd_signed_vma addend)
4212 {
4213   struct mips_got_info *g = arg->g;
4214   struct mips_got_page_entry lookup, *entry;
4215   struct mips_got_page_range **range_ptr, *range;
4216   bfd_vma old_pages, new_pages;
4217   void **loc;
4218
4219   /* Find the mips_got_page_entry hash table entry for this section.  */
4220   lookup.sec = sec;
4221   loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
4222   if (loc == NULL)
4223     return FALSE;
4224
4225   /* Create a mips_got_page_entry if this is the first time we've
4226      seen the section.  */
4227   entry = (struct mips_got_page_entry *) *loc;
4228   if (!entry)
4229     {
4230       entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry));
4231       if (!entry)
4232         return FALSE;
4233
4234       entry->sec = sec;
4235       *loc = entry;
4236     }
4237
4238   /* Skip over ranges whose maximum extent cannot share a page entry
4239      with ADDEND.  */
4240   range_ptr = &entry->ranges;
4241   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4242     range_ptr = &(*range_ptr)->next;
4243
4244   /* If we scanned to the end of the list, or found a range whose
4245      minimum extent cannot share a page entry with ADDEND, create
4246      a new singleton range.  */
4247   range = *range_ptr;
4248   if (!range || addend < range->min_addend - 0xffff)
4249     {
4250       range = bfd_zalloc (arg->info->output_bfd, sizeof (*range));
4251       if (!range)
4252         return FALSE;
4253
4254       range->next = *range_ptr;
4255       range->min_addend = addend;
4256       range->max_addend = addend;
4257
4258       *range_ptr = range;
4259       entry->num_pages++;
4260       g->page_gotno++;
4261       return TRUE;
4262     }
4263
4264   /* Remember how many pages the old range contributed.  */
4265   old_pages = mips_elf_pages_for_range (range);
4266
4267   /* Update the ranges.  */
4268   if (addend < range->min_addend)
4269     range->min_addend = addend;
4270   else if (addend > range->max_addend)
4271     {
4272       if (range->next && addend >= range->next->min_addend - 0xffff)
4273         {
4274           old_pages += mips_elf_pages_for_range (range->next);
4275           range->max_addend = range->next->max_addend;
4276           range->next = range->next->next;
4277         }
4278       else
4279         range->max_addend = addend;
4280     }
4281
4282   /* Record any change in the total estimate.  */
4283   new_pages = mips_elf_pages_for_range (range);
4284   if (old_pages != new_pages)
4285     {
4286       entry->num_pages += new_pages - old_pages;
4287       g->page_gotno += new_pages - old_pages;
4288     }
4289
4290   return TRUE;
4291 }
4292
4293 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4294    and for which DATA points to a mips_elf_traverse_got_arg.  Work out
4295    whether the page reference described by *REFP needs a GOT page entry,
4296    and record that entry in DATA->g if so.  Set DATA->g to null on failure.  */
4297
4298 static bfd_boolean
4299 mips_elf_resolve_got_page_ref (void **refp, void *data)
4300 {
4301   struct mips_got_page_ref *ref;
4302   struct mips_elf_traverse_got_arg *arg;
4303   struct mips_elf_link_hash_table *htab;
4304   asection *sec;
4305   bfd_vma addend;
4306
4307   ref = (struct mips_got_page_ref *) *refp;
4308   arg = (struct mips_elf_traverse_got_arg *) data;
4309   htab = mips_elf_hash_table (arg->info);
4310
4311   if (ref->symndx < 0)
4312     {
4313       struct mips_elf_link_hash_entry *h;
4314
4315       /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries.  */
4316       h = ref->u.h;
4317       if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root))
4318         return 1;
4319
4320       /* Ignore undefined symbols; we'll issue an error later if
4321          appropriate.  */
4322       if (!((h->root.root.type == bfd_link_hash_defined
4323              || h->root.root.type == bfd_link_hash_defweak)
4324             && h->root.root.u.def.section))
4325         return 1;
4326
4327       sec = h->root.root.u.def.section;
4328       addend = h->root.root.u.def.value + ref->addend;
4329     }
4330   else
4331     {
4332       Elf_Internal_Sym *isym;
4333
4334       /* Read in the symbol.  */
4335       isym = bfd_sym_from_r_symndx (&htab->sym_cache, ref->u.abfd,
4336                                     ref->symndx);
4337       if (isym == NULL)
4338         {
4339           arg->g = NULL;
4340           return 0;
4341         }
4342
4343       /* Get the associated input section.  */
4344       sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx);
4345       if (sec == NULL)
4346         {
4347           arg->g = NULL;
4348           return 0;
4349         }
4350
4351       /* If this is a mergable section, work out the section and offset
4352          of the merged data.  For section symbols, the addend specifies
4353          of the offset _of_ the first byte in the data, otherwise it
4354          specifies the offset _from_ the first byte.  */
4355       if (sec->flags & SEC_MERGE)
4356         {
4357           void *secinfo;
4358
4359           secinfo = elf_section_data (sec)->sec_info;
4360           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4361             addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4362                                                  isym->st_value + ref->addend);
4363           else
4364             addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4365                                                  isym->st_value) + ref->addend;
4366         }
4367       else
4368         addend = isym->st_value + ref->addend;
4369     }
4370   if (!mips_elf_record_got_page_entry (arg, sec, addend))
4371     {
4372       arg->g = NULL;
4373       return 0;
4374     }
4375   return 1;
4376 }
4377
4378 /* If any entries in G->got_entries are for indirect or warning symbols,
4379    replace them with entries for the target symbol.  Convert g->got_page_refs
4380    into got_page_entry structures and estimate the number of page entries
4381    that they require.  */
4382
4383 static bfd_boolean
4384 mips_elf_resolve_final_got_entries (struct bfd_link_info *info,
4385                                     struct mips_got_info *g)
4386 {
4387   struct mips_elf_traverse_got_arg tga;
4388   struct mips_got_info oldg;
4389
4390   oldg = *g;
4391
4392   tga.info = info;
4393   tga.g = g;
4394   tga.value = FALSE;
4395   htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga);
4396   if (tga.value)
4397     {
4398       *g = oldg;
4399       g->got_entries = htab_create (htab_size (oldg.got_entries),
4400                                     mips_elf_got_entry_hash,
4401                                     mips_elf_got_entry_eq, NULL);
4402       if (!g->got_entries)
4403         return FALSE;
4404
4405       htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga);
4406       if (!tga.g)
4407         return FALSE;
4408
4409       htab_delete (oldg.got_entries);
4410     }
4411
4412   g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4413                                          mips_got_page_entry_eq, NULL);
4414   if (g->got_page_entries == NULL)
4415     return FALSE;
4416
4417   tga.info = info;
4418   tga.g = g;
4419   htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga);
4420
4421   return TRUE;
4422 }
4423
4424 /* Return true if a GOT entry for H should live in the local rather than
4425    global GOT area.  */
4426
4427 static bfd_boolean
4428 mips_use_local_got_p (struct bfd_link_info *info,
4429                       struct mips_elf_link_hash_entry *h)
4430 {
4431   /* Symbols that aren't in the dynamic symbol table must live in the
4432      local GOT.  This includes symbols that are completely undefined
4433      and which therefore don't bind locally.  We'll report undefined
4434      symbols later if appropriate.  */
4435   if (h->root.dynindx == -1)
4436     return TRUE;
4437
4438   /* Symbols that bind locally can (and in the case of forced-local
4439      symbols, must) live in the local GOT.  */
4440   if (h->got_only_for_calls
4441       ? SYMBOL_CALLS_LOCAL (info, &h->root)
4442       : SYMBOL_REFERENCES_LOCAL (info, &h->root))
4443     return TRUE;
4444
4445   /* If this is an executable that must provide a definition of the symbol,
4446      either though PLTs or copy relocations, then that address should go in
4447      the local rather than global GOT.  */
4448   if (bfd_link_executable (info) && h->has_static_relocs)
4449     return TRUE;
4450
4451   return FALSE;
4452 }
4453
4454 /* A mips_elf_link_hash_traverse callback for which DATA points to the
4455    link_info structure.  Decide whether the hash entry needs an entry in
4456    the global part of the primary GOT, setting global_got_area accordingly.
4457    Count the number of global symbols that are in the primary GOT only
4458    because they have relocations against them (reloc_only_gotno).  */
4459
4460 static int
4461 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4462 {
4463   struct bfd_link_info *info;
4464   struct mips_elf_link_hash_table *htab;
4465   struct mips_got_info *g;
4466
4467   info = (struct bfd_link_info *) data;
4468   htab = mips_elf_hash_table (info);
4469   g = htab->got_info;
4470   if (h->global_got_area != GGA_NONE)
4471     {
4472       /* Make a final decision about whether the symbol belongs in the
4473          local or global GOT.  */
4474       if (mips_use_local_got_p (info, h))
4475         /* The symbol belongs in the local GOT.  We no longer need this
4476            entry if it was only used for relocations; those relocations
4477            will be against the null or section symbol instead of H.  */
4478         h->global_got_area = GGA_NONE;
4479       else if (htab->is_vxworks
4480                && h->got_only_for_calls
4481                && h->root.plt.plist->mips_offset != MINUS_ONE)
4482         /* On VxWorks, calls can refer directly to the .got.plt entry;
4483            they don't need entries in the regular GOT.  .got.plt entries
4484            will be allocated by _bfd_mips_elf_adjust_dynamic_symbol.  */
4485         h->global_got_area = GGA_NONE;
4486       else if (h->global_got_area == GGA_RELOC_ONLY)
4487         {
4488           g->reloc_only_gotno++;
4489           g->global_gotno++;
4490         }
4491     }
4492   return 1;
4493 }
4494 \f
4495 /* A htab_traverse callback for GOT entries.  Add each one to the GOT
4496    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
4497
4498 static int
4499 mips_elf_add_got_entry (void **entryp, void *data)
4500 {
4501   struct mips_got_entry *entry;
4502   struct mips_elf_traverse_got_arg *arg;
4503   void **slot;
4504
4505   entry = (struct mips_got_entry *) *entryp;
4506   arg = (struct mips_elf_traverse_got_arg *) data;
4507   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4508   if (!slot)
4509     {
4510       arg->g = NULL;
4511       return 0;
4512     }
4513   if (!*slot)
4514     {
4515       *slot = entry;
4516       mips_elf_count_got_entry (arg->info, arg->g, entry);
4517     }
4518   return 1;
4519 }
4520
4521 /* A htab_traverse callback for GOT page entries.  Add each one to the GOT
4522    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
4523
4524 static int
4525 mips_elf_add_got_page_entry (void **entryp, void *data)
4526 {
4527   struct mips_got_page_entry *entry;
4528   struct mips_elf_traverse_got_arg *arg;
4529   void **slot;
4530
4531   entry = (struct mips_got_page_entry *) *entryp;
4532   arg = (struct mips_elf_traverse_got_arg *) data;
4533   slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT);
4534   if (!slot)
4535     {
4536       arg->g = NULL;
4537       return 0;
4538     }
4539   if (!*slot)
4540     {
4541       *slot = entry;
4542       arg->g->page_gotno += entry->num_pages;
4543     }
4544   return 1;
4545 }
4546
4547 /* Consider merging FROM, which is ABFD's GOT, into TO.  Return -1 if
4548    this would lead to overflow, 1 if they were merged successfully,
4549    and 0 if a merge failed due to lack of memory.  (These values are chosen
4550    so that nonnegative return values can be returned by a htab_traverse
4551    callback.)  */
4552
4553 static int
4554 mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from,
4555                          struct mips_got_info *to,
4556                          struct mips_elf_got_per_bfd_arg *arg)
4557 {
4558   struct mips_elf_traverse_got_arg tga;
4559   unsigned int estimate;
4560
4561   /* Work out how many page entries we would need for the combined GOT.  */
4562   estimate = arg->max_pages;
4563   if (estimate >= from->page_gotno + to->page_gotno)
4564     estimate = from->page_gotno + to->page_gotno;
4565
4566   /* And conservatively estimate how many local and TLS entries
4567      would be needed.  */
4568   estimate += from->local_gotno + to->local_gotno;
4569   estimate += from->tls_gotno + to->tls_gotno;
4570
4571   /* If we're merging with the primary got, any TLS relocations will
4572      come after the full set of global entries.  Otherwise estimate those
4573      conservatively as well.  */
4574   if (to == arg->primary && from->tls_gotno + to->tls_gotno)
4575     estimate += arg->global_count;
4576   else
4577     estimate += from->global_gotno + to->global_gotno;
4578
4579   /* Bail out if the combined GOT might be too big.  */
4580   if (estimate > arg->max_count)
4581     return -1;
4582
4583   /* Transfer the bfd's got information from FROM to TO.  */
4584   tga.info = arg->info;
4585   tga.g = to;
4586   htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga);
4587   if (!tga.g)
4588     return 0;
4589
4590   htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga);
4591   if (!tga.g)
4592     return 0;
4593
4594   mips_elf_replace_bfd_got (abfd, to);
4595   return 1;
4596 }
4597
4598 /* Attempt to merge GOT G, which belongs to ABFD.  Try to use as much
4599    as possible of the primary got, since it doesn't require explicit
4600    dynamic relocations, but don't use bfds that would reference global
4601    symbols out of the addressable range.  Failing the primary got,
4602    attempt to merge with the current got, or finish the current got
4603    and then make make the new got current.  */
4604
4605 static bfd_boolean
4606 mips_elf_merge_got (bfd *abfd, struct mips_got_info *g,
4607                     struct mips_elf_got_per_bfd_arg *arg)
4608 {
4609   unsigned int estimate;
4610   int result;
4611
4612   if (!mips_elf_resolve_final_got_entries (arg->info, g))
4613     return FALSE;
4614
4615   /* Work out the number of page, local and TLS entries.  */
4616   estimate = arg->max_pages;
4617   if (estimate > g->page_gotno)
4618     estimate = g->page_gotno;
4619   estimate += g->local_gotno + g->tls_gotno;
4620
4621   /* We place TLS GOT entries after both locals and globals.  The globals
4622      for the primary GOT may overflow the normal GOT size limit, so be
4623      sure not to merge a GOT which requires TLS with the primary GOT in that
4624      case.  This doesn't affect non-primary GOTs.  */
4625   estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4626
4627   if (estimate <= arg->max_count)
4628     {
4629       /* If we don't have a primary GOT, use it as
4630          a starting point for the primary GOT.  */
4631       if (!arg->primary)
4632         {
4633           arg->primary = g;
4634           return TRUE;
4635         }
4636
4637       /* Try merging with the primary GOT.  */
4638       result = mips_elf_merge_got_with (abfd, g, arg->primary, arg);
4639       if (result >= 0)
4640         return result;
4641     }
4642
4643   /* If we can merge with the last-created got, do it.  */
4644   if (arg->current)
4645     {
4646       result = mips_elf_merge_got_with (abfd, g, arg->current, arg);
4647       if (result >= 0)
4648         return result;
4649     }
4650
4651   /* Well, we couldn't merge, so create a new GOT.  Don't check if it
4652      fits; if it turns out that it doesn't, we'll get relocation
4653      overflows anyway.  */
4654   g->next = arg->current;
4655   arg->current = g;
4656
4657   return TRUE;
4658 }
4659
4660 /* ENTRYP is a hash table entry for a mips_got_entry.  Set its gotidx
4661    to GOTIDX, duplicating the entry if it has already been assigned
4662    an index in a different GOT.  */
4663
4664 static bfd_boolean
4665 mips_elf_set_gotidx (void **entryp, long gotidx)
4666 {
4667   struct mips_got_entry *entry;
4668
4669   entry = (struct mips_got_entry *) *entryp;
4670   if (entry->gotidx > 0)
4671     {
4672       struct mips_got_entry *new_entry;
4673
4674       new_entry = bfd_alloc (entry->abfd, sizeof (*entry));
4675       if (!new_entry)
4676         return FALSE;
4677
4678       *new_entry = *entry;
4679       *entryp = new_entry;
4680       entry = new_entry;
4681     }
4682   entry->gotidx = gotidx;
4683   return TRUE;
4684 }
4685
4686 /* Set the TLS GOT index for the GOT entry in ENTRYP.  DATA points to a
4687    mips_elf_traverse_got_arg in which DATA->value is the size of one
4688    GOT entry.  Set DATA->g to null on failure.  */
4689
4690 static int
4691 mips_elf_initialize_tls_index (void **entryp, void *data)
4692 {
4693   struct mips_got_entry *entry;
4694   struct mips_elf_traverse_got_arg *arg;
4695
4696   /* We're only interested in TLS symbols.  */
4697   entry = (struct mips_got_entry *) *entryp;
4698   if (entry->tls_type == GOT_TLS_NONE)
4699     return 1;
4700
4701   arg = (struct mips_elf_traverse_got_arg *) data;
4702   if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno))
4703     {
4704       arg->g = NULL;
4705       return 0;
4706     }
4707
4708   /* Account for the entries we've just allocated.  */
4709   arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type);
4710   return 1;
4711 }
4712
4713 /* A htab_traverse callback for GOT entries, where DATA points to a
4714    mips_elf_traverse_got_arg.  Set the global_got_area of each global
4715    symbol to DATA->value.  */
4716
4717 static int
4718 mips_elf_set_global_got_area (void **entryp, void *data)
4719 {
4720   struct mips_got_entry *entry;
4721   struct mips_elf_traverse_got_arg *arg;
4722
4723   entry = (struct mips_got_entry *) *entryp;
4724   arg = (struct mips_elf_traverse_got_arg *) data;
4725   if (entry->abfd != NULL
4726       && entry->symndx == -1
4727       && entry->d.h->global_got_area != GGA_NONE)
4728     entry->d.h->global_got_area = arg->value;
4729   return 1;
4730 }
4731
4732 /* A htab_traverse callback for secondary GOT entries, where DATA points
4733    to a mips_elf_traverse_got_arg.  Assign GOT indices to global entries
4734    and record the number of relocations they require.  DATA->value is
4735    the size of one GOT entry.  Set DATA->g to null on failure.  */
4736
4737 static int
4738 mips_elf_set_global_gotidx (void **entryp, void *data)
4739 {
4740   struct mips_got_entry *entry;
4741   struct mips_elf_traverse_got_arg *arg;
4742
4743   entry = (struct mips_got_entry *) *entryp;
4744   arg = (struct mips_elf_traverse_got_arg *) data;
4745   if (entry->abfd != NULL
4746       && entry->symndx == -1
4747       && entry->d.h->global_got_area != GGA_NONE)
4748     {
4749       if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno))
4750         {
4751           arg->g = NULL;
4752           return 0;
4753         }
4754       arg->g->assigned_low_gotno += 1;
4755
4756       if (bfd_link_pic (arg->info)
4757           || (elf_hash_table (arg->info)->dynamic_sections_created
4758               && entry->d.h->root.def_dynamic
4759               && !entry->d.h->root.def_regular))
4760         arg->g->relocs += 1;
4761     }
4762
4763   return 1;
4764 }
4765
4766 /* A htab_traverse callback for GOT entries for which DATA is the
4767    bfd_link_info.  Forbid any global symbols from having traditional
4768    lazy-binding stubs.  */
4769
4770 static int
4771 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4772 {
4773   struct bfd_link_info *info;
4774   struct mips_elf_link_hash_table *htab;
4775   struct mips_got_entry *entry;
4776
4777   entry = (struct mips_got_entry *) *entryp;
4778   info = (struct bfd_link_info *) data;
4779   htab = mips_elf_hash_table (info);
4780   BFD_ASSERT (htab != NULL);
4781
4782   if (entry->abfd != NULL
4783       && entry->symndx == -1
4784       && entry->d.h->needs_lazy_stub)
4785     {
4786       entry->d.h->needs_lazy_stub = FALSE;
4787       htab->lazy_stub_count--;
4788     }
4789
4790   return 1;
4791 }
4792
4793 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4794    the primary GOT.  */
4795 static bfd_vma
4796 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4797 {
4798   if (!g->next)
4799     return 0;
4800
4801   g = mips_elf_bfd_got (ibfd, FALSE);
4802   if (! g)
4803     return 0;
4804
4805   BFD_ASSERT (g->next);
4806
4807   g = g->next;
4808
4809   return (g->local_gotno + g->global_gotno + g->tls_gotno)
4810     * MIPS_ELF_GOT_SIZE (abfd);
4811 }
4812
4813 /* Turn a single GOT that is too big for 16-bit addressing into
4814    a sequence of GOTs, each one 16-bit addressable.  */
4815
4816 static bfd_boolean
4817 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4818                     asection *got, bfd_size_type pages)
4819 {
4820   struct mips_elf_link_hash_table *htab;
4821   struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4822   struct mips_elf_traverse_got_arg tga;
4823   struct mips_got_info *g, *gg;
4824   unsigned int assign, needed_relocs;
4825   bfd *dynobj, *ibfd;
4826
4827   dynobj = elf_hash_table (info)->dynobj;
4828   htab = mips_elf_hash_table (info);
4829   BFD_ASSERT (htab != NULL);
4830
4831   g = htab->got_info;
4832
4833   got_per_bfd_arg.obfd = abfd;
4834   got_per_bfd_arg.info = info;
4835   got_per_bfd_arg.current = NULL;
4836   got_per_bfd_arg.primary = NULL;
4837   got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4838                                 / MIPS_ELF_GOT_SIZE (abfd))
4839                                - htab->reserved_gotno);
4840   got_per_bfd_arg.max_pages = pages;
4841   /* The number of globals that will be included in the primary GOT.
4842      See the calls to mips_elf_set_global_got_area below for more
4843      information.  */
4844   got_per_bfd_arg.global_count = g->global_gotno;
4845
4846   /* Try to merge the GOTs of input bfds together, as long as they
4847      don't seem to exceed the maximum GOT size, choosing one of them
4848      to be the primary GOT.  */
4849   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4850     {
4851       gg = mips_elf_bfd_got (ibfd, FALSE);
4852       if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg))
4853         return FALSE;
4854     }
4855
4856   /* If we do not find any suitable primary GOT, create an empty one.  */
4857   if (got_per_bfd_arg.primary == NULL)
4858     g->next = mips_elf_create_got_info (abfd);
4859   else
4860     g->next = got_per_bfd_arg.primary;
4861   g->next->next = got_per_bfd_arg.current;
4862
4863   /* GG is now the master GOT, and G is the primary GOT.  */
4864   gg = g;
4865   g = g->next;
4866
4867   /* Map the output bfd to the primary got.  That's what we're going
4868      to use for bfds that use GOT16 or GOT_PAGE relocations that we
4869      didn't mark in check_relocs, and we want a quick way to find it.
4870      We can't just use gg->next because we're going to reverse the
4871      list.  */
4872   mips_elf_replace_bfd_got (abfd, g);
4873
4874   /* Every symbol that is referenced in a dynamic relocation must be
4875      present in the primary GOT, so arrange for them to appear after
4876      those that are actually referenced.  */
4877   gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4878   g->global_gotno = gg->global_gotno;
4879
4880   tga.info = info;
4881   tga.value = GGA_RELOC_ONLY;
4882   htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
4883   tga.value = GGA_NORMAL;
4884   htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
4885
4886   /* Now go through the GOTs assigning them offset ranges.
4887      [assigned_low_gotno, local_gotno[ will be set to the range of local
4888      entries in each GOT.  We can then compute the end of a GOT by
4889      adding local_gotno to global_gotno.  We reverse the list and make
4890      it circular since then we'll be able to quickly compute the
4891      beginning of a GOT, by computing the end of its predecessor.  To
4892      avoid special cases for the primary GOT, while still preserving
4893      assertions that are valid for both single- and multi-got links,
4894      we arrange for the main got struct to have the right number of
4895      global entries, but set its local_gotno such that the initial
4896      offset of the primary GOT is zero.  Remember that the primary GOT
4897      will become the last item in the circular linked list, so it
4898      points back to the master GOT.  */
4899   gg->local_gotno = -g->global_gotno;
4900   gg->global_gotno = g->global_gotno;
4901   gg->tls_gotno = 0;
4902   assign = 0;
4903   gg->next = gg;
4904
4905   do
4906     {
4907       struct mips_got_info *gn;
4908
4909       assign += htab->reserved_gotno;
4910       g->assigned_low_gotno = assign;
4911       g->local_gotno += assign;
4912       g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4913       g->assigned_high_gotno = g->local_gotno - 1;
4914       assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4915
4916       /* Take g out of the direct list, and push it onto the reversed
4917          list that gg points to.  g->next is guaranteed to be nonnull after
4918          this operation, as required by mips_elf_initialize_tls_index. */
4919       gn = g->next;
4920       g->next = gg->next;
4921       gg->next = g;
4922
4923       /* Set up any TLS entries.  We always place the TLS entries after
4924          all non-TLS entries.  */
4925       g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4926       tga.g = g;
4927       tga.value = MIPS_ELF_GOT_SIZE (abfd);
4928       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
4929       if (!tga.g)
4930         return FALSE;
4931       BFD_ASSERT (g->tls_assigned_gotno == assign);
4932
4933       /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
4934       g = gn;
4935
4936       /* Forbid global symbols in every non-primary GOT from having
4937          lazy-binding stubs.  */
4938       if (g)
4939         htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4940     }
4941   while (g);
4942
4943   got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
4944
4945   needed_relocs = 0;
4946   for (g = gg->next; g && g->next != gg; g = g->next)
4947     {
4948       unsigned int save_assign;
4949
4950       /* Assign offsets to global GOT entries and count how many
4951          relocations they need.  */
4952       save_assign = g->assigned_low_gotno;
4953       g->assigned_low_gotno = g->local_gotno;
4954       tga.info = info;
4955       tga.value = MIPS_ELF_GOT_SIZE (abfd);
4956       tga.g = g;
4957       htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
4958       if (!tga.g)
4959         return FALSE;
4960       BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno);
4961       g->assigned_low_gotno = save_assign;
4962
4963       if (bfd_link_pic (info))
4964         {
4965           g->relocs += g->local_gotno - g->assigned_low_gotno;
4966           BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno
4967                       + g->next->global_gotno
4968                       + g->next->tls_gotno
4969                       + htab->reserved_gotno);
4970         }
4971       needed_relocs += g->relocs;
4972     }
4973   needed_relocs += g->relocs;
4974
4975   if (needed_relocs)
4976     mips_elf_allocate_dynamic_relocations (dynobj, info,
4977                                            needed_relocs);
4978
4979   return TRUE;
4980 }
4981
4982 \f
4983 /* Returns the first relocation of type r_type found, beginning with
4984    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
4985
4986 static const Elf_Internal_Rela *
4987 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4988                           const Elf_Internal_Rela *relocation,
4989                           const Elf_Internal_Rela *relend)
4990 {
4991   unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4992
4993   while (relocation < relend)
4994     {
4995       if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4996           && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4997         return relocation;
4998
4999       ++relocation;
5000     }
5001
5002   /* We didn't find it.  */
5003   return NULL;
5004 }
5005
5006 /* Return whether an input relocation is against a local symbol.  */
5007
5008 static bfd_boolean
5009 mips_elf_local_relocation_p (bfd *input_bfd,
5010                              const Elf_Internal_Rela *relocation,
5011                              asection **local_sections)
5012 {
5013   unsigned long r_symndx;
5014   Elf_Internal_Shdr *symtab_hdr;
5015   size_t extsymoff;
5016
5017   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5018   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5019   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5020
5021   if (r_symndx < extsymoff)
5022     return TRUE;
5023   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5024     return TRUE;
5025
5026   return FALSE;
5027 }
5028 \f
5029 /* Sign-extend VALUE, which has the indicated number of BITS.  */
5030
5031 bfd_vma
5032 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
5033 {
5034   if (value & ((bfd_vma) 1 << (bits - 1)))
5035     /* VALUE is negative.  */
5036     value |= ((bfd_vma) - 1) << bits;
5037
5038   return value;
5039 }
5040
5041 /* Return non-zero if the indicated VALUE has overflowed the maximum
5042    range expressible by a signed number with the indicated number of
5043    BITS.  */
5044
5045 static bfd_boolean
5046 mips_elf_overflow_p (bfd_vma value, int bits)
5047 {
5048   bfd_signed_vma svalue = (bfd_signed_vma) value;
5049
5050   if (svalue > (1 << (bits - 1)) - 1)
5051     /* The value is too big.  */
5052     return TRUE;
5053   else if (svalue < -(1 << (bits - 1)))
5054     /* The value is too small.  */
5055     return TRUE;
5056
5057   /* All is well.  */
5058   return FALSE;
5059 }
5060
5061 /* Calculate the %high function.  */
5062
5063 static bfd_vma
5064 mips_elf_high (bfd_vma value)
5065 {
5066   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5067 }
5068
5069 /* Calculate the %higher function.  */
5070
5071 static bfd_vma
5072 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
5073 {
5074 #ifdef BFD64
5075   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5076 #else
5077   abort ();
5078   return MINUS_ONE;
5079 #endif
5080 }
5081
5082 /* Calculate the %highest function.  */
5083
5084 static bfd_vma
5085 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
5086 {
5087 #ifdef BFD64
5088   return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
5089 #else
5090   abort ();
5091   return MINUS_ONE;
5092 #endif
5093 }
5094 \f
5095 /* Create the .compact_rel section.  */
5096
5097 static bfd_boolean
5098 mips_elf_create_compact_rel_section
5099   (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
5100 {
5101   flagword flags;
5102   register asection *s;
5103
5104   if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
5105     {
5106       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
5107                | SEC_READONLY);
5108
5109       s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
5110       if (s == NULL
5111           || ! bfd_set_section_alignment (abfd, s,
5112                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
5113         return FALSE;
5114
5115       s->size = sizeof (Elf32_External_compact_rel);
5116     }
5117
5118   return TRUE;
5119 }
5120
5121 /* Create the .got section to hold the global offset table.  */
5122
5123 static bfd_boolean
5124 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
5125 {
5126   flagword flags;
5127   register asection *s;
5128   struct elf_link_hash_entry *h;
5129   struct bfd_link_hash_entry *bh;
5130   struct mips_elf_link_hash_table *htab;
5131
5132   htab = mips_elf_hash_table (info);
5133   BFD_ASSERT (htab != NULL);
5134
5135   /* This function may be called more than once.  */
5136   if (htab->root.sgot)
5137     return TRUE;
5138
5139   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5140            | SEC_LINKER_CREATED);
5141
5142   /* We have to use an alignment of 2**4 here because this is hardcoded
5143      in the function stub generation and in the linker script.  */
5144   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
5145   if (s == NULL
5146       || ! bfd_set_section_alignment (abfd, s, 4))
5147     return FALSE;
5148   htab->root.sgot = s;
5149
5150   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
5151      linker script because we don't want to define the symbol if we
5152      are not creating a global offset table.  */
5153   bh = NULL;
5154   if (! (_bfd_generic_link_add_one_symbol
5155          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5156           0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5157     return FALSE;
5158
5159   h = (struct elf_link_hash_entry *) bh;
5160   h->non_elf = 0;
5161   h->def_regular = 1;
5162   h->type = STT_OBJECT;
5163   h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
5164   elf_hash_table (info)->hgot = h;
5165
5166   if (bfd_link_pic (info)
5167       && ! bfd_elf_link_record_dynamic_symbol (info, h))
5168     return FALSE;
5169
5170   htab->got_info = mips_elf_create_got_info (abfd);
5171   mips_elf_section_data (s)->elf.this_hdr.sh_flags
5172     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5173
5174   /* We also need a .got.plt section when generating PLTs.  */
5175   s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
5176                                           SEC_ALLOC | SEC_LOAD
5177                                           | SEC_HAS_CONTENTS
5178                                           | SEC_IN_MEMORY
5179                                           | SEC_LINKER_CREATED);
5180   if (s == NULL)
5181     return FALSE;
5182   htab->root.sgotplt = s;
5183
5184   return TRUE;
5185 }
5186 \f
5187 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5188    __GOTT_INDEX__ symbols.  These symbols are only special for
5189    shared objects; they are not used in executables.  */
5190
5191 static bfd_boolean
5192 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
5193 {
5194   return (mips_elf_hash_table (info)->is_vxworks
5195           && bfd_link_pic (info)
5196           && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
5197               || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
5198 }
5199
5200 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5201    require an la25 stub.  See also mips_elf_local_pic_function_p,
5202    which determines whether the destination function ever requires a
5203    stub.  */
5204
5205 static bfd_boolean
5206 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
5207                                      bfd_boolean target_is_16_bit_code_p)
5208 {
5209   /* We specifically ignore branches and jumps from EF_PIC objects,
5210      where the onus is on the compiler or programmer to perform any
5211      necessary initialization of $25.  Sometimes such initialization
5212      is unnecessary; for example, -mno-shared functions do not use
5213      the incoming value of $25, and may therefore be called directly.  */
5214   if (PIC_OBJECT_P (input_bfd))
5215     return FALSE;
5216
5217   switch (r_type)
5218     {
5219     case R_MIPS_26:
5220     case R_MIPS_PC16:
5221     case R_MIPS_PC21_S2:
5222     case R_MIPS_PC26_S2:
5223     case R_MICROMIPS_26_S1:
5224     case R_MICROMIPS_PC7_S1:
5225     case R_MICROMIPS_PC10_S1:
5226     case R_MICROMIPS_PC16_S1:
5227     case R_MICROMIPS_PC23_S2:
5228       return TRUE;
5229
5230     case R_MIPS16_26:
5231       return !target_is_16_bit_code_p;
5232
5233     default:
5234       return FALSE;
5235     }
5236 }
5237 \f
5238 /* Calculate the value produced by the RELOCATION (which comes from
5239    the INPUT_BFD).  The ADDEND is the addend to use for this
5240    RELOCATION; RELOCATION->R_ADDEND is ignored.
5241
5242    The result of the relocation calculation is stored in VALUEP.
5243    On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5244    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5245
5246    This function returns bfd_reloc_continue if the caller need take no
5247    further action regarding this relocation, bfd_reloc_notsupported if
5248    something goes dramatically wrong, bfd_reloc_overflow if an
5249    overflow occurs, and bfd_reloc_ok to indicate success.  */
5250
5251 static bfd_reloc_status_type
5252 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
5253                                asection *input_section,
5254                                struct bfd_link_info *info,
5255                                const Elf_Internal_Rela *relocation,
5256                                bfd_vma addend, reloc_howto_type *howto,
5257                                Elf_Internal_Sym *local_syms,
5258                                asection **local_sections, bfd_vma *valuep,
5259                                const char **namep,
5260                                bfd_boolean *cross_mode_jump_p,
5261                                bfd_boolean save_addend)
5262 {
5263   /* The eventual value we will return.  */
5264   bfd_vma value;
5265   /* The address of the symbol against which the relocation is
5266      occurring.  */
5267   bfd_vma symbol = 0;
5268   /* The final GP value to be used for the relocatable, executable, or
5269      shared object file being produced.  */
5270   bfd_vma gp;
5271   /* The place (section offset or address) of the storage unit being
5272      relocated.  */
5273   bfd_vma p;
5274   /* The value of GP used to create the relocatable object.  */
5275   bfd_vma gp0;
5276   /* The offset into the global offset table at which the address of
5277      the relocation entry symbol, adjusted by the addend, resides
5278      during execution.  */
5279   bfd_vma g = MINUS_ONE;
5280   /* The section in which the symbol referenced by the relocation is
5281      located.  */
5282   asection *sec = NULL;
5283   struct mips_elf_link_hash_entry *h = NULL;
5284   /* TRUE if the symbol referred to by this relocation is a local
5285      symbol.  */
5286   bfd_boolean local_p, was_local_p;
5287   /* TRUE if the symbol referred to by this relocation is a section
5288      symbol.  */
5289   bfd_boolean section_p = FALSE;
5290   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
5291   bfd_boolean gp_disp_p = FALSE;
5292   /* TRUE if the symbol referred to by this relocation is
5293      "__gnu_local_gp".  */
5294   bfd_boolean gnu_local_gp_p = FALSE;
5295   Elf_Internal_Shdr *symtab_hdr;
5296   size_t extsymoff;
5297   unsigned long r_symndx;
5298   int r_type;
5299   /* TRUE if overflow occurred during the calculation of the
5300      relocation value.  */
5301   bfd_boolean overflowed_p;
5302   /* TRUE if this relocation refers to a MIPS16 function.  */
5303   bfd_boolean target_is_16_bit_code_p = FALSE;
5304   bfd_boolean target_is_micromips_code_p = FALSE;
5305   struct mips_elf_link_hash_table *htab;
5306   bfd *dynobj;
5307
5308   dynobj = elf_hash_table (info)->dynobj;
5309   htab = mips_elf_hash_table (info);
5310   BFD_ASSERT (htab != NULL);
5311
5312   /* Parse the relocation.  */
5313   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5314   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5315   p = (input_section->output_section->vma
5316        + input_section->output_offset
5317        + relocation->r_offset);
5318
5319   /* Assume that there will be no overflow.  */
5320   overflowed_p = FALSE;
5321
5322   /* Figure out whether or not the symbol is local, and get the offset
5323      used in the array of hash table entries.  */
5324   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5325   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5326                                          local_sections);
5327   was_local_p = local_p;
5328   if (! elf_bad_symtab (input_bfd))
5329     extsymoff = symtab_hdr->sh_info;
5330   else
5331     {
5332       /* The symbol table does not follow the rule that local symbols
5333          must come before globals.  */
5334       extsymoff = 0;
5335     }
5336
5337   /* Figure out the value of the symbol.  */
5338   if (local_p)
5339     {
5340       bfd_boolean micromips_p = MICROMIPS_P (abfd);
5341       Elf_Internal_Sym *sym;
5342
5343       sym = local_syms + r_symndx;
5344       sec = local_sections[r_symndx];
5345
5346       section_p = ELF_ST_TYPE (sym->st_info) == STT_SECTION;
5347
5348       symbol = sec->output_section->vma + sec->output_offset;
5349       if (!section_p || (sec->flags & SEC_MERGE))
5350         symbol += sym->st_value;
5351       if ((sec->flags & SEC_MERGE) && section_p)
5352         {
5353           addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5354           addend -= symbol;
5355           addend += sec->output_section->vma + sec->output_offset;
5356         }
5357
5358       /* MIPS16/microMIPS text labels should be treated as odd.  */
5359       if (ELF_ST_IS_COMPRESSED (sym->st_other))
5360         ++symbol;
5361
5362       /* Record the name of this symbol, for our caller.  */
5363       *namep = bfd_elf_string_from_elf_section (input_bfd,
5364                                                 symtab_hdr->sh_link,
5365                                                 sym->st_name);
5366       if (*namep == NULL || **namep == '\0')
5367         *namep = bfd_section_name (input_bfd, sec);
5368
5369       /* For relocations against a section symbol and ones against no
5370          symbol (absolute relocations) infer the ISA mode from the addend.  */
5371       if (section_p || r_symndx == STN_UNDEF)
5372         {
5373           target_is_16_bit_code_p = (addend & 1) && !micromips_p;
5374           target_is_micromips_code_p = (addend & 1) && micromips_p;
5375         }
5376       /* For relocations against an absolute symbol infer the ISA mode
5377          from the value of the symbol plus addend.  */
5378       else if (bfd_is_abs_section (sec))
5379         {
5380           target_is_16_bit_code_p = ((symbol + addend) & 1) && !micromips_p;
5381           target_is_micromips_code_p = ((symbol + addend) & 1) && micromips_p;
5382         }
5383       /* Otherwise just use the regular symbol annotation available.  */
5384       else
5385         {
5386           target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5387           target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5388         }
5389     }
5390   else
5391     {
5392       /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
5393
5394       /* For global symbols we look up the symbol in the hash-table.  */
5395       h = ((struct mips_elf_link_hash_entry *)
5396            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5397       /* Find the real hash-table entry for this symbol.  */
5398       while (h->root.root.type == bfd_link_hash_indirect
5399              || h->root.root.type == bfd_link_hash_warning)
5400         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5401
5402       /* Record the name of this symbol, for our caller.  */
5403       *namep = h->root.root.root.string;
5404
5405       /* See if this is the special _gp_disp symbol.  Note that such a
5406          symbol must always be a global symbol.  */
5407       if (strcmp (*namep, "_gp_disp") == 0
5408           && ! NEWABI_P (input_bfd))
5409         {
5410           /* Relocations against _gp_disp are permitted only with
5411              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
5412           if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5413             return bfd_reloc_notsupported;
5414
5415           gp_disp_p = TRUE;
5416         }
5417       /* See if this is the special _gp symbol.  Note that such a
5418          symbol must always be a global symbol.  */
5419       else if (strcmp (*namep, "__gnu_local_gp") == 0)
5420         gnu_local_gp_p = TRUE;
5421
5422
5423       /* If this symbol is defined, calculate its address.  Note that
5424          _gp_disp is a magic symbol, always implicitly defined by the
5425          linker, so it's inappropriate to check to see whether or not
5426          its defined.  */
5427       else if ((h->root.root.type == bfd_link_hash_defined
5428                 || h->root.root.type == bfd_link_hash_defweak)
5429                && h->root.root.u.def.section)
5430         {
5431           sec = h->root.root.u.def.section;
5432           if (sec->output_section)
5433             symbol = (h->root.root.u.def.value
5434                       + sec->output_section->vma
5435                       + sec->output_offset);
5436           else
5437             symbol = h->root.root.u.def.value;
5438         }
5439       else if (h->root.root.type == bfd_link_hash_undefweak)
5440         /* We allow relocations against undefined weak symbols, giving
5441            it the value zero, so that you can undefined weak functions
5442            and check to see if they exist by looking at their
5443            addresses.  */
5444         symbol = 0;
5445       else if (info->unresolved_syms_in_objects == RM_IGNORE
5446                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5447         symbol = 0;
5448       else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5449                        ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5450         {
5451           /* If this is a dynamic link, we should have created a
5452              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5453              in in _bfd_mips_elf_create_dynamic_sections.
5454              Otherwise, we should define the symbol with a value of 0.
5455              FIXME: It should probably get into the symbol table
5456              somehow as well.  */
5457           BFD_ASSERT (! bfd_link_pic (info));
5458           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5459           symbol = 0;
5460         }
5461       else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5462         {
5463           /* This is an optional symbol - an Irix specific extension to the
5464              ELF spec.  Ignore it for now.
5465              XXX - FIXME - there is more to the spec for OPTIONAL symbols
5466              than simply ignoring them, but we do not handle this for now.
5467              For information see the "64-bit ELF Object File Specification"
5468              which is available from here:
5469              http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
5470           symbol = 0;
5471         }
5472       else
5473         {
5474           (*info->callbacks->undefined_symbol)
5475             (info, h->root.root.root.string, input_bfd,
5476              input_section, relocation->r_offset,
5477              (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5478              || ELF_ST_VISIBILITY (h->root.other));
5479           return bfd_reloc_undefined;
5480         }
5481
5482       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5483       target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other);
5484     }
5485
5486   /* If this is a reference to a 16-bit function with a stub, we need
5487      to redirect the relocation to the stub unless:
5488
5489      (a) the relocation is for a MIPS16 JAL;
5490
5491      (b) the relocation is for a MIPS16 PIC call, and there are no
5492          non-MIPS16 uses of the GOT slot; or
5493
5494      (c) the section allows direct references to MIPS16 functions.  */
5495   if (r_type != R_MIPS16_26
5496       && !bfd_link_relocatable (info)
5497       && ((h != NULL
5498            && h->fn_stub != NULL
5499            && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5500           || (local_p
5501               && mips_elf_tdata (input_bfd)->local_stubs != NULL
5502               && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5503       && !section_allows_mips16_refs_p (input_section))
5504     {
5505       /* This is a 32- or 64-bit call to a 16-bit function.  We should
5506          have already noticed that we were going to need the
5507          stub.  */
5508       if (local_p)
5509         {
5510           sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx];
5511           value = 0;
5512         }
5513       else
5514         {
5515           BFD_ASSERT (h->need_fn_stub);
5516           if (h->la25_stub)
5517             {
5518               /* If a LA25 header for the stub itself exists, point to the
5519                  prepended LUI/ADDIU sequence.  */
5520               sec = h->la25_stub->stub_section;
5521               value = h->la25_stub->offset;
5522             }
5523           else
5524             {
5525               sec = h->fn_stub;
5526               value = 0;
5527             }
5528         }
5529
5530       symbol = sec->output_section->vma + sec->output_offset + value;
5531       /* The target is 16-bit, but the stub isn't.  */
5532       target_is_16_bit_code_p = FALSE;
5533     }
5534   /* If this is a MIPS16 call with a stub, that is made through the PLT or
5535      to a standard MIPS function, we need to redirect the call to the stub.
5536      Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5537      indirect calls should use an indirect stub instead.  */
5538   else if (r_type == R_MIPS16_26 && !bfd_link_relocatable (info)
5539            && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5540                || (local_p
5541                    && mips_elf_tdata (input_bfd)->local_call_stubs != NULL
5542                    && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5543            && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p))
5544     {
5545       if (local_p)
5546         sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5547       else
5548         {
5549           /* If both call_stub and call_fp_stub are defined, we can figure
5550              out which one to use by checking which one appears in the input
5551              file.  */
5552           if (h->call_stub != NULL && h->call_fp_stub != NULL)
5553             {
5554               asection *o;
5555
5556               sec = NULL;
5557               for (o = input_bfd->sections; o != NULL; o = o->next)
5558                 {
5559                   if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5560                     {
5561                       sec = h->call_fp_stub;
5562                       break;
5563                     }
5564                 }
5565               if (sec == NULL)
5566                 sec = h->call_stub;
5567             }
5568           else if (h->call_stub != NULL)
5569             sec = h->call_stub;
5570           else
5571             sec = h->call_fp_stub;
5572         }
5573
5574       BFD_ASSERT (sec->size > 0);
5575       symbol = sec->output_section->vma + sec->output_offset;
5576     }
5577   /* If this is a direct call to a PIC function, redirect to the
5578      non-PIC stub.  */
5579   else if (h != NULL && h->la25_stub
5580            && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5581                                                    target_is_16_bit_code_p))
5582     {
5583         symbol = (h->la25_stub->stub_section->output_section->vma
5584                   + h->la25_stub->stub_section->output_offset
5585                   + h->la25_stub->offset);
5586         if (ELF_ST_IS_MICROMIPS (h->root.other))
5587           symbol |= 1;
5588     }
5589   /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5590      entry is used if a standard PLT entry has also been made.  In this
5591      case the symbol will have been set by mips_elf_set_plt_sym_value
5592      to point to the standard PLT entry, so redirect to the compressed
5593      one.  */
5594   else if ((mips16_branch_reloc_p (r_type)
5595             || micromips_branch_reloc_p (r_type))
5596            && !bfd_link_relocatable (info)
5597            && h != NULL
5598            && h->use_plt_entry
5599            && h->root.plt.plist->comp_offset != MINUS_ONE
5600            && h->root.plt.plist->mips_offset != MINUS_ONE)
5601     {
5602       bfd_boolean micromips_p = MICROMIPS_P (abfd);
5603
5604       sec = htab->root.splt;
5605       symbol = (sec->output_section->vma
5606                 + sec->output_offset
5607                 + htab->plt_header_size
5608                 + htab->plt_mips_offset
5609                 + h->root.plt.plist->comp_offset
5610                 + 1);
5611
5612       target_is_16_bit_code_p = !micromips_p;
5613       target_is_micromips_code_p = micromips_p;
5614     }
5615
5616   /* Make sure MIPS16 and microMIPS are not used together.  */
5617   if ((mips16_branch_reloc_p (r_type) && target_is_micromips_code_p)
5618       || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5619    {
5620       _bfd_error_handler
5621         (_("MIPS16 and microMIPS functions cannot call each other"));
5622       return bfd_reloc_notsupported;
5623    }
5624
5625   /* Calls from 16-bit code to 32-bit code and vice versa require the
5626      mode change.  However, we can ignore calls to undefined weak symbols,
5627      which should never be executed at runtime.  This exception is important
5628      because the assembly writer may have "known" that any definition of the
5629      symbol would be 16-bit code, and that direct jumps were therefore
5630      acceptable.  */
5631   *cross_mode_jump_p = (!bfd_link_relocatable (info)
5632                         && !(h && h->root.root.type == bfd_link_hash_undefweak)
5633                         && ((mips16_branch_reloc_p (r_type)
5634                              && !target_is_16_bit_code_p)
5635                             || (micromips_branch_reloc_p (r_type)
5636                                 && !target_is_micromips_code_p)
5637                             || ((branch_reloc_p (r_type)
5638                                  || r_type == R_MIPS_JALR)
5639                                 && (target_is_16_bit_code_p
5640                                     || target_is_micromips_code_p))));
5641
5642   local_p = (h == NULL || mips_use_local_got_p (info, h));
5643
5644   gp0 = _bfd_get_gp_value (input_bfd);
5645   gp = _bfd_get_gp_value (abfd);
5646   if (htab->got_info)
5647     gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5648
5649   if (gnu_local_gp_p)
5650     symbol = gp;
5651
5652   /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5653      to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
5654      corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.  */
5655   if (got_page_reloc_p (r_type) && !local_p)
5656     {
5657       r_type = (micromips_reloc_p (r_type)
5658                 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5659       addend = 0;
5660     }
5661
5662   /* If we haven't already determined the GOT offset, and we're going
5663      to need it, get it now.  */
5664   switch (r_type)
5665     {
5666     case R_MIPS16_CALL16:
5667     case R_MIPS16_GOT16:
5668     case R_MIPS_CALL16:
5669     case R_MIPS_GOT16:
5670     case R_MIPS_GOT_DISP:
5671     case R_MIPS_GOT_HI16:
5672     case R_MIPS_CALL_HI16:
5673     case R_MIPS_GOT_LO16:
5674     case R_MIPS_CALL_LO16:
5675     case R_MICROMIPS_CALL16:
5676     case R_MICROMIPS_GOT16:
5677     case R_MICROMIPS_GOT_DISP:
5678     case R_MICROMIPS_GOT_HI16:
5679     case R_MICROMIPS_CALL_HI16:
5680     case R_MICROMIPS_GOT_LO16:
5681     case R_MICROMIPS_CALL_LO16:
5682     case R_MIPS_TLS_GD:
5683     case R_MIPS_TLS_GOTTPREL:
5684     case R_MIPS_TLS_LDM:
5685     case R_MIPS16_TLS_GD:
5686     case R_MIPS16_TLS_GOTTPREL:
5687     case R_MIPS16_TLS_LDM:
5688     case R_MICROMIPS_TLS_GD:
5689     case R_MICROMIPS_TLS_GOTTPREL:
5690     case R_MICROMIPS_TLS_LDM:
5691       /* Find the index into the GOT where this value is located.  */
5692       if (tls_ldm_reloc_p (r_type))
5693         {
5694           g = mips_elf_local_got_index (abfd, input_bfd, info,
5695                                         0, 0, NULL, r_type);
5696           if (g == MINUS_ONE)
5697             return bfd_reloc_outofrange;
5698         }
5699       else if (!local_p)
5700         {
5701           /* On VxWorks, CALL relocations should refer to the .got.plt
5702              entry, which is initialized to point at the PLT stub.  */
5703           if (htab->is_vxworks
5704               && (call_hi16_reloc_p (r_type)
5705                   || call_lo16_reloc_p (r_type)
5706                   || call16_reloc_p (r_type)))
5707             {
5708               BFD_ASSERT (addend == 0);
5709               BFD_ASSERT (h->root.needs_plt);
5710               g = mips_elf_gotplt_index (info, &h->root);
5711             }
5712           else
5713             {
5714               BFD_ASSERT (addend == 0);
5715               g = mips_elf_global_got_index (abfd, info, input_bfd,
5716                                              &h->root, r_type);
5717               if (!TLS_RELOC_P (r_type)
5718                   && !elf_hash_table (info)->dynamic_sections_created)
5719                 /* This is a static link.  We must initialize the GOT entry.  */
5720                 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->root.sgot->contents + g);
5721             }
5722         }
5723       else if (!htab->is_vxworks
5724                && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5725         /* The calculation below does not involve "g".  */
5726         break;
5727       else
5728         {
5729           g = mips_elf_local_got_index (abfd, input_bfd, info,
5730                                         symbol + addend, r_symndx, h, r_type);
5731           if (g == MINUS_ONE)
5732             return bfd_reloc_outofrange;
5733         }
5734
5735       /* Convert GOT indices to actual offsets.  */
5736       g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5737       break;
5738     }
5739
5740   /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5741      symbols are resolved by the loader.  Add them to .rela.dyn.  */
5742   if (h != NULL && is_gott_symbol (info, &h->root))
5743     {
5744       Elf_Internal_Rela outrel;
5745       bfd_byte *loc;
5746       asection *s;
5747
5748       s = mips_elf_rel_dyn_section (info, FALSE);
5749       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5750
5751       outrel.r_offset = (input_section->output_section->vma
5752                          + input_section->output_offset
5753                          + relocation->r_offset);
5754       outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5755       outrel.r_addend = addend;
5756       bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5757
5758       /* If we've written this relocation for a readonly section,
5759          we need to set DF_TEXTREL again, so that we do not delete the
5760          DT_TEXTREL tag.  */
5761       if (MIPS_ELF_READONLY_SECTION (input_section))
5762         info->flags |= DF_TEXTREL;
5763
5764       *valuep = 0;
5765       return bfd_reloc_ok;
5766     }
5767
5768   /* Figure out what kind of relocation is being performed.  */
5769   switch (r_type)
5770     {
5771     case R_MIPS_NONE:
5772       return bfd_reloc_continue;
5773
5774     case R_MIPS_16:
5775       if (howto->partial_inplace)
5776         addend = _bfd_mips_elf_sign_extend (addend, 16);
5777       value = symbol + addend;
5778       overflowed_p = mips_elf_overflow_p (value, 16);
5779       break;
5780
5781     case R_MIPS_32:
5782     case R_MIPS_REL32:
5783     case R_MIPS_64:
5784       if ((bfd_link_pic (info)
5785            || (htab->root.dynamic_sections_created
5786                && h != NULL
5787                && h->root.def_dynamic
5788                && !h->root.def_regular
5789                && !h->has_static_relocs))
5790           && r_symndx != STN_UNDEF
5791           && (h == NULL
5792               || h->root.root.type != bfd_link_hash_undefweak
5793               || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5794           && (input_section->flags & SEC_ALLOC) != 0)
5795         {
5796           /* If we're creating a shared library, then we can't know
5797              where the symbol will end up.  So, we create a relocation
5798              record in the output, and leave the job up to the dynamic
5799              linker.  We must do the same for executable references to
5800              shared library symbols, unless we've decided to use copy
5801              relocs or PLTs instead.  */
5802           value = addend;
5803           if (!mips_elf_create_dynamic_relocation (abfd,
5804                                                    info,
5805                                                    relocation,
5806                                                    h,
5807                                                    sec,
5808                                                    symbol,
5809                                                    &value,
5810                                                    input_section))
5811             return bfd_reloc_undefined;
5812         }
5813       else
5814         {
5815           if (r_type != R_MIPS_REL32)
5816             value = symbol + addend;
5817           else
5818             value = addend;
5819         }
5820       value &= howto->dst_mask;
5821       break;
5822
5823     case R_MIPS_PC32:
5824       value = symbol + addend - p;
5825       value &= howto->dst_mask;
5826       break;
5827
5828     case R_MIPS16_26:
5829       /* The calculation for R_MIPS16_26 is just the same as for an
5830          R_MIPS_26.  It's only the storage of the relocated field into
5831          the output file that's different.  That's handled in
5832          mips_elf_perform_relocation.  So, we just fall through to the
5833          R_MIPS_26 case here.  */
5834     case R_MIPS_26:
5835     case R_MICROMIPS_26_S1:
5836       {
5837         unsigned int shift;
5838
5839         /* Shift is 2, unusually, for microMIPS JALX.  */
5840         shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5841
5842         if (howto->partial_inplace && !section_p)
5843           value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5844         else
5845           value = addend;
5846         value += symbol;
5847
5848         /* Make sure the target of a jump is suitably aligned.  Bit 0 must
5849            be the correct ISA mode selector except for weak undefined
5850            symbols.  */
5851         if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5852             && (*cross_mode_jump_p
5853                 ? (value & 3) != (r_type == R_MIPS_26)
5854                 : (value & ((1 << shift) - 1)) != (r_type != R_MIPS_26)))
5855           return bfd_reloc_outofrange;
5856
5857         value >>= shift;
5858         if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5859           overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5860         value &= howto->dst_mask;
5861       }
5862       break;
5863
5864     case R_MIPS_TLS_DTPREL_HI16:
5865     case R_MIPS16_TLS_DTPREL_HI16:
5866     case R_MICROMIPS_TLS_DTPREL_HI16:
5867       value = (mips_elf_high (addend + symbol - dtprel_base (info))
5868                & howto->dst_mask);
5869       break;
5870
5871     case R_MIPS_TLS_DTPREL_LO16:
5872     case R_MIPS_TLS_DTPREL32:
5873     case R_MIPS_TLS_DTPREL64:
5874     case R_MIPS16_TLS_DTPREL_LO16:
5875     case R_MICROMIPS_TLS_DTPREL_LO16:
5876       value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5877       break;
5878
5879     case R_MIPS_TLS_TPREL_HI16:
5880     case R_MIPS16_TLS_TPREL_HI16:
5881     case R_MICROMIPS_TLS_TPREL_HI16:
5882       value = (mips_elf_high (addend + symbol - tprel_base (info))
5883                & howto->dst_mask);
5884       break;
5885
5886     case R_MIPS_TLS_TPREL_LO16:
5887     case R_MIPS_TLS_TPREL32:
5888     case R_MIPS_TLS_TPREL64:
5889     case R_MIPS16_TLS_TPREL_LO16:
5890     case R_MICROMIPS_TLS_TPREL_LO16:
5891       value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5892       break;
5893
5894     case R_MIPS_HI16:
5895     case R_MIPS16_HI16:
5896     case R_MICROMIPS_HI16:
5897       if (!gp_disp_p)
5898         {
5899           value = mips_elf_high (addend + symbol);
5900           value &= howto->dst_mask;
5901         }
5902       else
5903         {
5904           /* For MIPS16 ABI code we generate this sequence
5905                 0: li      $v0,%hi(_gp_disp)
5906                 4: addiupc $v1,%lo(_gp_disp)
5907                 8: sll     $v0,16
5908                12: addu    $v0,$v1
5909                14: move    $gp,$v0
5910              So the offsets of hi and lo relocs are the same, but the
5911              base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5912              ADDIUPC clears the low two bits of the instruction address,
5913              so the base is ($t9 + 4) & ~3.  */
5914           if (r_type == R_MIPS16_HI16)
5915             value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
5916           /* The microMIPS .cpload sequence uses the same assembly
5917              instructions as the traditional psABI version, but the
5918              incoming $t9 has the low bit set.  */
5919           else if (r_type == R_MICROMIPS_HI16)
5920             value = mips_elf_high (addend + gp - p - 1);
5921           else
5922             value = mips_elf_high (addend + gp - p);
5923         }
5924       break;
5925
5926     case R_MIPS_LO16:
5927     case R_MIPS16_LO16:
5928     case R_MICROMIPS_LO16:
5929     case R_MICROMIPS_HI0_LO16:
5930       if (!gp_disp_p)
5931         value = (symbol + addend) & howto->dst_mask;
5932       else
5933         {
5934           /* See the comment for R_MIPS16_HI16 above for the reason
5935              for this conditional.  */
5936           if (r_type == R_MIPS16_LO16)
5937             value = addend + gp - (p & ~(bfd_vma) 0x3);
5938           else if (r_type == R_MICROMIPS_LO16
5939                    || r_type == R_MICROMIPS_HI0_LO16)
5940             value = addend + gp - p + 3;
5941           else
5942             value = addend + gp - p + 4;
5943           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5944              for overflow.  But, on, say, IRIX5, relocations against
5945              _gp_disp are normally generated from the .cpload
5946              pseudo-op.  It generates code that normally looks like
5947              this:
5948
5949                lui    $gp,%hi(_gp_disp)
5950                addiu  $gp,$gp,%lo(_gp_disp)
5951                addu   $gp,$gp,$t9
5952
5953              Here $t9 holds the address of the function being called,
5954              as required by the MIPS ELF ABI.  The R_MIPS_LO16
5955              relocation can easily overflow in this situation, but the
5956              R_MIPS_HI16 relocation will handle the overflow.
5957              Therefore, we consider this a bug in the MIPS ABI, and do
5958              not check for overflow here.  */
5959         }
5960       break;
5961
5962     case R_MIPS_LITERAL:
5963     case R_MICROMIPS_LITERAL:
5964       /* Because we don't merge literal sections, we can handle this
5965          just like R_MIPS_GPREL16.  In the long run, we should merge
5966          shared literals, and then we will need to additional work
5967          here.  */
5968
5969       /* Fall through.  */
5970
5971     case R_MIPS16_GPREL:
5972       /* The R_MIPS16_GPREL performs the same calculation as
5973          R_MIPS_GPREL16, but stores the relocated bits in a different
5974          order.  We don't need to do anything special here; the
5975          differences are handled in mips_elf_perform_relocation.  */
5976     case R_MIPS_GPREL16:
5977     case R_MICROMIPS_GPREL7_S2:
5978     case R_MICROMIPS_GPREL16:
5979       /* Only sign-extend the addend if it was extracted from the
5980          instruction.  If the addend was separate, leave it alone,
5981          otherwise we may lose significant bits.  */
5982       if (howto->partial_inplace)
5983         addend = _bfd_mips_elf_sign_extend (addend, 16);
5984       value = symbol + addend - gp;
5985       /* If the symbol was local, any earlier relocatable links will
5986          have adjusted its addend with the gp offset, so compensate
5987          for that now.  Don't do it for symbols forced local in this
5988          link, though, since they won't have had the gp offset applied
5989          to them before.  */
5990       if (was_local_p)
5991         value += gp0;
5992       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5993         overflowed_p = mips_elf_overflow_p (value, 16);
5994       break;
5995
5996     case R_MIPS16_GOT16:
5997     case R_MIPS16_CALL16:
5998     case R_MIPS_GOT16:
5999     case R_MIPS_CALL16:
6000     case R_MICROMIPS_GOT16:
6001     case R_MICROMIPS_CALL16:
6002       /* VxWorks does not have separate local and global semantics for
6003          R_MIPS*_GOT16; every relocation evaluates to "G".  */
6004       if (!htab->is_vxworks && local_p)
6005         {
6006           value = mips_elf_got16_entry (abfd, input_bfd, info,
6007                                         symbol + addend, !was_local_p);
6008           if (value == MINUS_ONE)
6009             return bfd_reloc_outofrange;
6010           value
6011             = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6012           overflowed_p = mips_elf_overflow_p (value, 16);
6013           break;
6014         }
6015
6016       /* Fall through.  */
6017
6018     case R_MIPS_TLS_GD:
6019     case R_MIPS_TLS_GOTTPREL:
6020     case R_MIPS_TLS_LDM:
6021     case R_MIPS_GOT_DISP:
6022     case R_MIPS16_TLS_GD:
6023     case R_MIPS16_TLS_GOTTPREL:
6024     case R_MIPS16_TLS_LDM:
6025     case R_MICROMIPS_TLS_GD:
6026     case R_MICROMIPS_TLS_GOTTPREL:
6027     case R_MICROMIPS_TLS_LDM:
6028     case R_MICROMIPS_GOT_DISP:
6029       value = g;
6030       overflowed_p = mips_elf_overflow_p (value, 16);
6031       break;
6032
6033     case R_MIPS_GPREL32:
6034       value = (addend + symbol + gp0 - gp);
6035       if (!save_addend)
6036         value &= howto->dst_mask;
6037       break;
6038
6039     case R_MIPS_PC16:
6040     case R_MIPS_GNU_REL16_S2:
6041       if (howto->partial_inplace)
6042         addend = _bfd_mips_elf_sign_extend (addend, 18);
6043
6044       /* No need to exclude weak undefined symbols here as they resolve
6045          to 0 and never set `*cross_mode_jump_p', so this alignment check
6046          will never trigger for them.  */
6047       if (*cross_mode_jump_p
6048           ? ((symbol + addend) & 3) != 1
6049           : ((symbol + addend) & 3) != 0)
6050         return bfd_reloc_outofrange;
6051
6052       value = symbol + addend - p;
6053       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6054         overflowed_p = mips_elf_overflow_p (value, 18);
6055       value >>= howto->rightshift;
6056       value &= howto->dst_mask;
6057       break;
6058
6059     case R_MIPS16_PC16_S1:
6060       if (howto->partial_inplace)
6061         addend = _bfd_mips_elf_sign_extend (addend, 17);
6062
6063       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6064           && (*cross_mode_jump_p
6065               ? ((symbol + addend) & 3) != 0
6066               : ((symbol + addend) & 1) == 0))
6067         return bfd_reloc_outofrange;
6068
6069       value = symbol + addend - p;
6070       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6071         overflowed_p = mips_elf_overflow_p (value, 17);
6072       value >>= howto->rightshift;
6073       value &= howto->dst_mask;
6074       break;
6075
6076     case R_MIPS_PC21_S2:
6077       if (howto->partial_inplace)
6078         addend = _bfd_mips_elf_sign_extend (addend, 23);
6079
6080       if ((symbol + addend) & 3)
6081         return bfd_reloc_outofrange;
6082
6083       value = symbol + addend - p;
6084       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6085         overflowed_p = mips_elf_overflow_p (value, 23);
6086       value >>= howto->rightshift;
6087       value &= howto->dst_mask;
6088       break;
6089
6090     case R_MIPS_PC26_S2:
6091       if (howto->partial_inplace)
6092         addend = _bfd_mips_elf_sign_extend (addend, 28);
6093
6094       if ((symbol + addend) & 3)
6095         return bfd_reloc_outofrange;
6096
6097       value = symbol + addend - p;
6098       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6099         overflowed_p = mips_elf_overflow_p (value, 28);
6100       value >>= howto->rightshift;
6101       value &= howto->dst_mask;
6102       break;
6103
6104     case R_MIPS_PC18_S3:
6105       if (howto->partial_inplace)
6106         addend = _bfd_mips_elf_sign_extend (addend, 21);
6107
6108       if ((symbol + addend) & 7)
6109         return bfd_reloc_outofrange;
6110
6111       value = symbol + addend - ((p | 7) ^ 7);
6112       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6113         overflowed_p = mips_elf_overflow_p (value, 21);
6114       value >>= howto->rightshift;
6115       value &= howto->dst_mask;
6116       break;
6117
6118     case R_MIPS_PC19_S2:
6119       if (howto->partial_inplace)
6120         addend = _bfd_mips_elf_sign_extend (addend, 21);
6121
6122       if ((symbol + addend) & 3)
6123         return bfd_reloc_outofrange;
6124
6125       value = symbol + addend - p;
6126       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6127         overflowed_p = mips_elf_overflow_p (value, 21);
6128       value >>= howto->rightshift;
6129       value &= howto->dst_mask;
6130       break;
6131
6132     case R_MIPS_PCHI16:
6133       value = mips_elf_high (symbol + addend - p);
6134       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6135         overflowed_p = mips_elf_overflow_p (value, 16);
6136       value &= howto->dst_mask;
6137       break;
6138
6139     case R_MIPS_PCLO16:
6140       if (howto->partial_inplace)
6141         addend = _bfd_mips_elf_sign_extend (addend, 16);
6142       value = symbol + addend - p;
6143       value &= howto->dst_mask;
6144       break;
6145
6146     case R_MICROMIPS_PC7_S1:
6147       if (howto->partial_inplace)
6148         addend = _bfd_mips_elf_sign_extend (addend, 8);
6149
6150       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6151           && (*cross_mode_jump_p
6152               ? ((symbol + addend + 2) & 3) != 0
6153               : ((symbol + addend + 2) & 1) == 0))
6154         return bfd_reloc_outofrange;
6155
6156       value = symbol + addend - p;
6157       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6158         overflowed_p = mips_elf_overflow_p (value, 8);
6159       value >>= howto->rightshift;
6160       value &= howto->dst_mask;
6161       break;
6162
6163     case R_MICROMIPS_PC10_S1:
6164       if (howto->partial_inplace)
6165         addend = _bfd_mips_elf_sign_extend (addend, 11);
6166
6167       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6168           && (*cross_mode_jump_p
6169               ? ((symbol + addend + 2) & 3) != 0
6170               : ((symbol + addend + 2) & 1) == 0))
6171         return bfd_reloc_outofrange;
6172
6173       value = symbol + addend - p;
6174       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6175         overflowed_p = mips_elf_overflow_p (value, 11);
6176       value >>= howto->rightshift;
6177       value &= howto->dst_mask;
6178       break;
6179
6180     case R_MICROMIPS_PC16_S1:
6181       if (howto->partial_inplace)
6182         addend = _bfd_mips_elf_sign_extend (addend, 17);
6183
6184       if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6185           && (*cross_mode_jump_p
6186               ? ((symbol + addend) & 3) != 0
6187               : ((symbol + addend) & 1) == 0))
6188         return bfd_reloc_outofrange;
6189
6190       value = symbol + addend - p;
6191       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6192         overflowed_p = mips_elf_overflow_p (value, 17);
6193       value >>= howto->rightshift;
6194       value &= howto->dst_mask;
6195       break;
6196
6197     case R_MICROMIPS_PC23_S2:
6198       if (howto->partial_inplace)
6199         addend = _bfd_mips_elf_sign_extend (addend, 25);
6200       value = symbol + addend - ((p | 3) ^ 3);
6201       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6202         overflowed_p = mips_elf_overflow_p (value, 25);
6203       value >>= howto->rightshift;
6204       value &= howto->dst_mask;
6205       break;
6206
6207     case R_MIPS_GOT_HI16:
6208     case R_MIPS_CALL_HI16:
6209     case R_MICROMIPS_GOT_HI16:
6210     case R_MICROMIPS_CALL_HI16:
6211       /* We're allowed to handle these two relocations identically.
6212          The dynamic linker is allowed to handle the CALL relocations
6213          differently by creating a lazy evaluation stub.  */
6214       value = g;
6215       value = mips_elf_high (value);
6216       value &= howto->dst_mask;
6217       break;
6218
6219     case R_MIPS_GOT_LO16:
6220     case R_MIPS_CALL_LO16:
6221     case R_MICROMIPS_GOT_LO16:
6222     case R_MICROMIPS_CALL_LO16:
6223       value = g & howto->dst_mask;
6224       break;
6225
6226     case R_MIPS_GOT_PAGE:
6227     case R_MICROMIPS_GOT_PAGE:
6228       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
6229       if (value == MINUS_ONE)
6230         return bfd_reloc_outofrange;
6231       value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6232       overflowed_p = mips_elf_overflow_p (value, 16);
6233       break;
6234
6235     case R_MIPS_GOT_OFST:
6236     case R_MICROMIPS_GOT_OFST:
6237       if (local_p)
6238         mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
6239       else
6240         value = addend;
6241       overflowed_p = mips_elf_overflow_p (value, 16);
6242       break;
6243
6244     case R_MIPS_SUB:
6245     case R_MICROMIPS_SUB:
6246       value = symbol - addend;
6247       value &= howto->dst_mask;
6248       break;
6249
6250     case R_MIPS_HIGHER:
6251     case R_MICROMIPS_HIGHER:
6252       value = mips_elf_higher (addend + symbol);
6253       value &= howto->dst_mask;
6254       break;
6255
6256     case R_MIPS_HIGHEST:
6257     case R_MICROMIPS_HIGHEST:
6258       value = mips_elf_highest (addend + symbol);
6259       value &= howto->dst_mask;
6260       break;
6261
6262     case R_MIPS_SCN_DISP:
6263     case R_MICROMIPS_SCN_DISP:
6264       value = symbol + addend - sec->output_offset;
6265       value &= howto->dst_mask;
6266       break;
6267
6268     case R_MIPS_JALR:
6269     case R_MICROMIPS_JALR:
6270       /* This relocation is only a hint.  In some cases, we optimize
6271          it into a bal instruction.  But we don't try to optimize
6272          when the symbol does not resolve locally.  */
6273       if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
6274         return bfd_reloc_continue;
6275       value = symbol + addend;
6276       break;
6277
6278     case R_MIPS_PJUMP:
6279     case R_MIPS_GNU_VTINHERIT:
6280     case R_MIPS_GNU_VTENTRY:
6281       /* We don't do anything with these at present.  */
6282       return bfd_reloc_continue;
6283
6284     default:
6285       /* An unrecognized relocation type.  */
6286       return bfd_reloc_notsupported;
6287     }
6288
6289   /* Store the VALUE for our caller.  */
6290   *valuep = value;
6291   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6292 }
6293
6294 /* Obtain the field relocated by RELOCATION.  */
6295
6296 static bfd_vma
6297 mips_elf_obtain_contents (reloc_howto_type *howto,
6298                           const Elf_Internal_Rela *relocation,
6299                           bfd *input_bfd, bfd_byte *contents)
6300 {
6301   bfd_vma x = 0;
6302   bfd_byte *location = contents + relocation->r_offset;
6303   unsigned int size = bfd_get_reloc_size (howto);
6304
6305   /* Obtain the bytes.  */
6306   if (size != 0)
6307     x = bfd_get (8 * size, input_bfd, location);
6308
6309   return x;
6310 }
6311
6312 /* It has been determined that the result of the RELOCATION is the
6313    VALUE.  Use HOWTO to place VALUE into the output file at the
6314    appropriate position.  The SECTION is the section to which the
6315    relocation applies.
6316    CROSS_MODE_JUMP_P is true if the relocation field
6317    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
6318
6319    Returns FALSE if anything goes wrong.  */
6320
6321 static bfd_boolean
6322 mips_elf_perform_relocation (struct bfd_link_info *info,
6323                              reloc_howto_type *howto,
6324                              const Elf_Internal_Rela *relocation,
6325                              bfd_vma value, bfd *input_bfd,
6326                              asection *input_section, bfd_byte *contents,
6327                              bfd_boolean cross_mode_jump_p)
6328 {
6329   bfd_vma x;
6330   bfd_byte *location;
6331   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
6332   unsigned int size;
6333
6334   /* Figure out where the relocation is occurring.  */
6335   location = contents + relocation->r_offset;
6336
6337   _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
6338
6339   /* Obtain the current value.  */
6340   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6341
6342   /* Clear the field we are setting.  */
6343   x &= ~howto->dst_mask;
6344
6345   /* Set the field.  */
6346   x |= (value & howto->dst_mask);
6347
6348   /* Detect incorrect JALX usage.  If required, turn JAL or BAL into JALX.  */
6349   if (!cross_mode_jump_p && jal_reloc_p (r_type))
6350     {
6351       bfd_vma opcode = x >> 26;
6352
6353       if (r_type == R_MIPS16_26 ? opcode == 0x7
6354           : r_type == R_MICROMIPS_26_S1 ? opcode == 0x3c
6355           : opcode == 0x1d)
6356         {
6357           info->callbacks->einfo
6358             (_("%X%H: Unsupported JALX to the same ISA mode\n"),
6359              input_bfd, input_section, relocation->r_offset);
6360           return TRUE;
6361         }
6362     }
6363   if (cross_mode_jump_p && jal_reloc_p (r_type))
6364     {
6365       bfd_boolean ok;
6366       bfd_vma opcode = x >> 26;
6367       bfd_vma jalx_opcode;
6368
6369       /* Check to see if the opcode is already JAL or JALX.  */
6370       if (r_type == R_MIPS16_26)
6371         {
6372           ok = ((opcode == 0x6) || (opcode == 0x7));
6373           jalx_opcode = 0x7;
6374         }
6375       else if (r_type == R_MICROMIPS_26_S1)
6376         {
6377           ok = ((opcode == 0x3d) || (opcode == 0x3c));
6378           jalx_opcode = 0x3c;
6379         }
6380       else
6381         {
6382           ok = ((opcode == 0x3) || (opcode == 0x1d));
6383           jalx_opcode = 0x1d;
6384         }
6385
6386       /* If the opcode is not JAL or JALX, there's a problem.  We cannot
6387          convert J or JALS to JALX.  */
6388       if (!ok)
6389         {
6390           info->callbacks->einfo
6391             (_("%X%H: Unsupported jump between ISA modes; "
6392                "consider recompiling with interlinking enabled\n"),
6393              input_bfd, input_section, relocation->r_offset);
6394           return TRUE;
6395         }
6396
6397       /* Make this the JALX opcode.  */
6398       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6399     }
6400   else if (cross_mode_jump_p && b_reloc_p (r_type))
6401     {
6402       bfd_boolean ok = FALSE;
6403       bfd_vma opcode = x >> 16;
6404       bfd_vma jalx_opcode = 0;
6405       bfd_vma addr;
6406       bfd_vma dest;
6407
6408       if (r_type == R_MICROMIPS_PC16_S1)
6409         {
6410           ok = opcode == 0x4060;
6411           jalx_opcode = 0x3c;
6412           value <<= 1;
6413         }
6414       else if (r_type == R_MIPS_PC16 || r_type == R_MIPS_GNU_REL16_S2)
6415         {
6416           ok = opcode == 0x411;
6417           jalx_opcode = 0x1d;
6418           value <<= 2;
6419         }
6420
6421       if (bfd_link_pic (info) || !ok)
6422         {
6423           info->callbacks->einfo
6424             (_("%X%H: Unsupported branch between ISA modes\n"),
6425              input_bfd, input_section, relocation->r_offset);
6426           return TRUE;
6427         }
6428
6429       addr = (input_section->output_section->vma
6430               + input_section->output_offset
6431               + relocation->r_offset
6432               + 4);
6433       dest = addr + (((value & 0x3ffff) ^ 0x20000) - 0x20000);
6434
6435       if ((addr >> 28) << 28 != (dest >> 28) << 28)
6436         {
6437           info->callbacks->einfo
6438             (_("%X%H: Cannot convert branch between ISA modes "
6439                "to JALX: relocation out of range\n"),
6440              input_bfd, input_section, relocation->r_offset);
6441           return TRUE;
6442         }
6443
6444       /* Make this the JALX opcode.  */
6445       x = ((dest >> 2) & 0x3ffffff) | jalx_opcode << 26;
6446     }
6447
6448   /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6449      range.  */
6450   if (!bfd_link_relocatable (info)
6451       && !cross_mode_jump_p
6452       && ((JAL_TO_BAL_P (input_bfd)
6453            && r_type == R_MIPS_26
6454            && (x >> 26) == 0x3)         /* jal addr */
6455           || (JALR_TO_BAL_P (input_bfd)
6456               && r_type == R_MIPS_JALR
6457               && x == 0x0320f809)       /* jalr t9 */
6458           || (JR_TO_B_P (input_bfd)
6459               && r_type == R_MIPS_JALR
6460               && x == 0x03200008)))     /* jr t9 */
6461     {
6462       bfd_vma addr;
6463       bfd_vma dest;
6464       bfd_signed_vma off;
6465
6466       addr = (input_section->output_section->vma
6467               + input_section->output_offset
6468               + relocation->r_offset
6469               + 4);
6470       if (r_type == R_MIPS_26)
6471         dest = (value << 2) | ((addr >> 28) << 28);
6472       else
6473         dest = value;
6474       off = dest - addr;
6475       if (off <= 0x1ffff && off >= -0x20000)
6476         {
6477           if (x == 0x03200008)  /* jr t9 */
6478             x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff);   /* b addr */
6479           else
6480             x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
6481         }
6482     }
6483
6484   /* Put the value into the output.  */
6485   size = bfd_get_reloc_size (howto);
6486   if (size != 0)
6487     bfd_put (8 * size, input_bfd, x, location);
6488
6489   _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !bfd_link_relocatable (info),
6490                                location);
6491
6492   return TRUE;
6493 }
6494 \f
6495 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
6496    is the original relocation, which is now being transformed into a
6497    dynamic relocation.  The ADDENDP is adjusted if necessary; the
6498    caller should store the result in place of the original addend.  */
6499
6500 static bfd_boolean
6501 mips_elf_create_dynamic_relocation (bfd *output_bfd,
6502                                     struct bfd_link_info *info,
6503                                     const Elf_Internal_Rela *rel,
6504                                     struct mips_elf_link_hash_entry *h,
6505                                     asection *sec, bfd_vma symbol,
6506                                     bfd_vma *addendp, asection *input_section)
6507 {
6508   Elf_Internal_Rela outrel[3];
6509   asection *sreloc;
6510   bfd *dynobj;
6511   int r_type;
6512   long indx;
6513   bfd_boolean defined_p;
6514   struct mips_elf_link_hash_table *htab;
6515
6516   htab = mips_elf_hash_table (info);
6517   BFD_ASSERT (htab != NULL);
6518
6519   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6520   dynobj = elf_hash_table (info)->dynobj;
6521   sreloc = mips_elf_rel_dyn_section (info, FALSE);
6522   BFD_ASSERT (sreloc != NULL);
6523   BFD_ASSERT (sreloc->contents != NULL);
6524   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
6525               < sreloc->size);
6526
6527   outrel[0].r_offset =
6528     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
6529   if (ABI_64_P (output_bfd))
6530     {
6531       outrel[1].r_offset =
6532         _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6533       outrel[2].r_offset =
6534         _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6535     }
6536
6537   if (outrel[0].r_offset == MINUS_ONE)
6538     /* The relocation field has been deleted.  */
6539     return TRUE;
6540
6541   if (outrel[0].r_offset == MINUS_TWO)
6542     {
6543       /* The relocation field has been converted into a relative value of
6544          some sort.  Functions like _bfd_elf_write_section_eh_frame expect
6545          the field to be fully relocated, so add in the symbol's value.  */
6546       *addendp += symbol;
6547       return TRUE;
6548     }
6549
6550   /* We must now calculate the dynamic symbol table index to use
6551      in the relocation.  */
6552   if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6553     {
6554       BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6555       indx = h->root.dynindx;
6556       if (SGI_COMPAT (output_bfd))
6557         defined_p = h->root.def_regular;
6558       else
6559         /* ??? glibc's ld.so just adds the final GOT entry to the
6560            relocation field.  It therefore treats relocs against
6561            defined symbols in the same way as relocs against
6562            undefined symbols.  */
6563         defined_p = FALSE;
6564     }
6565   else
6566     {
6567       if (sec != NULL && bfd_is_abs_section (sec))
6568         indx = 0;
6569       else if (sec == NULL || sec->owner == NULL)
6570         {
6571           bfd_set_error (bfd_error_bad_value);
6572           return FALSE;
6573         }
6574       else
6575         {
6576           indx = elf_section_data (sec->output_section)->dynindx;
6577           if (indx == 0)
6578             {
6579               asection *osec = htab->root.text_index_section;
6580               indx = elf_section_data (osec)->dynindx;
6581             }
6582           if (indx == 0)
6583             abort ();
6584         }
6585
6586       /* Instead of generating a relocation using the section
6587          symbol, we may as well make it a fully relative
6588          relocation.  We want to avoid generating relocations to
6589          local symbols because we used to generate them
6590          incorrectly, without adding the original symbol value,
6591          which is mandated by the ABI for section symbols.  In
6592          order to give dynamic loaders and applications time to
6593          phase out the incorrect use, we refrain from emitting
6594          section-relative relocations.  It's not like they're
6595          useful, after all.  This should be a bit more efficient
6596          as well.  */
6597       /* ??? Although this behavior is compatible with glibc's ld.so,
6598          the ABI says that relocations against STN_UNDEF should have
6599          a symbol value of 0.  Irix rld honors this, so relocations
6600          against STN_UNDEF have no effect.  */
6601       if (!SGI_COMPAT (output_bfd))
6602         indx = 0;
6603       defined_p = TRUE;
6604     }
6605
6606   /* If the relocation was previously an absolute relocation and
6607      this symbol will not be referred to by the relocation, we must
6608      adjust it by the value we give it in the dynamic symbol table.
6609      Otherwise leave the job up to the dynamic linker.  */
6610   if (defined_p && r_type != R_MIPS_REL32)
6611     *addendp += symbol;
6612
6613   if (htab->is_vxworks)
6614     /* VxWorks uses non-relative relocations for this.  */
6615     outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6616   else
6617     /* The relocation is always an REL32 relocation because we don't
6618        know where the shared library will wind up at load-time.  */
6619     outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6620                                    R_MIPS_REL32);
6621
6622   /* For strict adherence to the ABI specification, we should
6623      generate a R_MIPS_64 relocation record by itself before the
6624      _REL32/_64 record as well, such that the addend is read in as
6625      a 64-bit value (REL32 is a 32-bit relocation, after all).
6626      However, since none of the existing ELF64 MIPS dynamic
6627      loaders seems to care, we don't waste space with these
6628      artificial relocations.  If this turns out to not be true,
6629      mips_elf_allocate_dynamic_relocation() should be tweaked so
6630      as to make room for a pair of dynamic relocations per
6631      invocation if ABI_64_P, and here we should generate an
6632      additional relocation record with R_MIPS_64 by itself for a
6633      NULL symbol before this relocation record.  */
6634   outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6635                                  ABI_64_P (output_bfd)
6636                                  ? R_MIPS_64
6637                                  : R_MIPS_NONE);
6638   outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6639
6640   /* Adjust the output offset of the relocation to reference the
6641      correct location in the output file.  */
6642   outrel[0].r_offset += (input_section->output_section->vma
6643                          + input_section->output_offset);
6644   outrel[1].r_offset += (input_section->output_section->vma
6645                          + input_section->output_offset);
6646   outrel[2].r_offset += (input_section->output_section->vma
6647                          + input_section->output_offset);
6648
6649   /* Put the relocation back out.  We have to use the special
6650      relocation outputter in the 64-bit case since the 64-bit
6651      relocation format is non-standard.  */
6652   if (ABI_64_P (output_bfd))
6653     {
6654       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6655         (output_bfd, &outrel[0],
6656          (sreloc->contents
6657           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6658     }
6659   else if (htab->is_vxworks)
6660     {
6661       /* VxWorks uses RELA rather than REL dynamic relocations.  */
6662       outrel[0].r_addend = *addendp;
6663       bfd_elf32_swap_reloca_out
6664         (output_bfd, &outrel[0],
6665          (sreloc->contents
6666           + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6667     }
6668   else
6669     bfd_elf32_swap_reloc_out
6670       (output_bfd, &outrel[0],
6671        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6672
6673   /* We've now added another relocation.  */
6674   ++sreloc->reloc_count;
6675
6676   /* Make sure the output section is writable.  The dynamic linker
6677      will be writing to it.  */
6678   elf_section_data (input_section->output_section)->this_hdr.sh_flags
6679     |= SHF_WRITE;
6680
6681   /* On IRIX5, make an entry of compact relocation info.  */
6682   if (IRIX_COMPAT (output_bfd) == ict_irix5)
6683     {
6684       asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6685       bfd_byte *cr;
6686
6687       if (scpt)
6688         {
6689           Elf32_crinfo cptrel;
6690
6691           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6692           cptrel.vaddr = (rel->r_offset
6693                           + input_section->output_section->vma
6694                           + input_section->output_offset);
6695           if (r_type == R_MIPS_REL32)
6696             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6697           else
6698             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6699           mips_elf_set_cr_dist2to (cptrel, 0);
6700           cptrel.konst = *addendp;
6701
6702           cr = (scpt->contents
6703                 + sizeof (Elf32_External_compact_rel));
6704           mips_elf_set_cr_relvaddr (cptrel, 0);
6705           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6706                                      ((Elf32_External_crinfo *) cr
6707                                       + scpt->reloc_count));
6708           ++scpt->reloc_count;
6709         }
6710     }
6711
6712   /* If we've written this relocation for a readonly section,
6713      we need to set DF_TEXTREL again, so that we do not delete the
6714      DT_TEXTREL tag.  */
6715   if (MIPS_ELF_READONLY_SECTION (input_section))
6716     info->flags |= DF_TEXTREL;
6717
6718   return TRUE;
6719 }
6720 \f
6721 /* Return the MACH for a MIPS e_flags value.  */
6722
6723 unsigned long
6724 _bfd_elf_mips_mach (flagword flags)
6725 {
6726   switch (flags & EF_MIPS_MACH)
6727     {
6728     case E_MIPS_MACH_3900:
6729       return bfd_mach_mips3900;
6730
6731     case E_MIPS_MACH_4010:
6732       return bfd_mach_mips4010;
6733
6734     case E_MIPS_MACH_4100:
6735       return bfd_mach_mips4100;
6736
6737     case E_MIPS_MACH_4111:
6738       return bfd_mach_mips4111;
6739
6740     case E_MIPS_MACH_4120:
6741       return bfd_mach_mips4120;
6742
6743     case E_MIPS_MACH_4650:
6744       return bfd_mach_mips4650;
6745
6746     case E_MIPS_MACH_5400:
6747       return bfd_mach_mips5400;
6748
6749     case E_MIPS_MACH_5500:
6750       return bfd_mach_mips5500;
6751
6752     case E_MIPS_MACH_5900:
6753       return bfd_mach_mips5900;
6754
6755     case E_MIPS_MACH_9000:
6756       return bfd_mach_mips9000;
6757
6758     case E_MIPS_MACH_SB1:
6759       return bfd_mach_mips_sb1;
6760
6761     case E_MIPS_MACH_LS2E:
6762       return bfd_mach_mips_loongson_2e;
6763
6764     case E_MIPS_MACH_LS2F:
6765       return bfd_mach_mips_loongson_2f;
6766
6767     case E_MIPS_MACH_LS3A:
6768       return bfd_mach_mips_loongson_3a;
6769
6770     case E_MIPS_MACH_OCTEON3:
6771       return bfd_mach_mips_octeon3;
6772
6773     case E_MIPS_MACH_OCTEON2:
6774       return bfd_mach_mips_octeon2;
6775
6776     case E_MIPS_MACH_OCTEON:
6777       return bfd_mach_mips_octeon;
6778
6779     case E_MIPS_MACH_XLR:
6780       return bfd_mach_mips_xlr;
6781
6782     default:
6783       switch (flags & EF_MIPS_ARCH)
6784         {
6785         default:
6786         case E_MIPS_ARCH_1:
6787           return bfd_mach_mips3000;
6788
6789         case E_MIPS_ARCH_2:
6790           return bfd_mach_mips6000;
6791
6792         case E_MIPS_ARCH_3:
6793           return bfd_mach_mips4000;
6794
6795         case E_MIPS_ARCH_4:
6796           return bfd_mach_mips8000;
6797
6798         case E_MIPS_ARCH_5:
6799           return bfd_mach_mips5;
6800
6801         case E_MIPS_ARCH_32:
6802           return bfd_mach_mipsisa32;
6803
6804         case E_MIPS_ARCH_64:
6805           return bfd_mach_mipsisa64;
6806
6807         case E_MIPS_ARCH_32R2:
6808           return bfd_mach_mipsisa32r2;
6809
6810         case E_MIPS_ARCH_64R2:
6811           return bfd_mach_mipsisa64r2;
6812
6813         case E_MIPS_ARCH_32R6:
6814           return bfd_mach_mipsisa32r6;
6815
6816         case E_MIPS_ARCH_64R6:
6817           return bfd_mach_mipsisa64r6;
6818         }
6819     }
6820
6821   return 0;
6822 }
6823
6824 /* Return printable name for ABI.  */
6825
6826 static INLINE char *
6827 elf_mips_abi_name (bfd *abfd)
6828 {
6829   flagword flags;
6830
6831   flags = elf_elfheader (abfd)->e_flags;
6832   switch (flags & EF_MIPS_ABI)
6833     {
6834     case 0:
6835       if (ABI_N32_P (abfd))
6836         return "N32";
6837       else if (ABI_64_P (abfd))
6838         return "64";
6839       else
6840         return "none";
6841     case E_MIPS_ABI_O32:
6842       return "O32";
6843     case E_MIPS_ABI_O64:
6844       return "O64";
6845     case E_MIPS_ABI_EABI32:
6846       return "EABI32";
6847     case E_MIPS_ABI_EABI64:
6848       return "EABI64";
6849     default:
6850       return "unknown abi";
6851     }
6852 }
6853 \f
6854 /* MIPS ELF uses two common sections.  One is the usual one, and the
6855    other is for small objects.  All the small objects are kept
6856    together, and then referenced via the gp pointer, which yields
6857    faster assembler code.  This is what we use for the small common
6858    section.  This approach is copied from ecoff.c.  */
6859 static asection mips_elf_scom_section;
6860 static asymbol mips_elf_scom_symbol;
6861 static asymbol *mips_elf_scom_symbol_ptr;
6862
6863 /* MIPS ELF also uses an acommon section, which represents an
6864    allocated common symbol which may be overridden by a
6865    definition in a shared library.  */
6866 static asection mips_elf_acom_section;
6867 static asymbol mips_elf_acom_symbol;
6868 static asymbol *mips_elf_acom_symbol_ptr;
6869
6870 /* This is used for both the 32-bit and the 64-bit ABI.  */
6871
6872 void
6873 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6874 {
6875   elf_symbol_type *elfsym;
6876
6877   /* Handle the special MIPS section numbers that a symbol may use.  */
6878   elfsym = (elf_symbol_type *) asym;
6879   switch (elfsym->internal_elf_sym.st_shndx)
6880     {
6881     case SHN_MIPS_ACOMMON:
6882       /* This section is used in a dynamically linked executable file.
6883          It is an allocated common section.  The dynamic linker can
6884          either resolve these symbols to something in a shared
6885          library, or it can just leave them here.  For our purposes,
6886          we can consider these symbols to be in a new section.  */
6887       if (mips_elf_acom_section.name == NULL)
6888         {
6889           /* Initialize the acommon section.  */
6890           mips_elf_acom_section.name = ".acommon";
6891           mips_elf_acom_section.flags = SEC_ALLOC;
6892           mips_elf_acom_section.output_section = &mips_elf_acom_section;
6893           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6894           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6895           mips_elf_acom_symbol.name = ".acommon";
6896           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6897           mips_elf_acom_symbol.section = &mips_elf_acom_section;
6898           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6899         }
6900       asym->section = &mips_elf_acom_section;
6901       break;
6902
6903     case SHN_COMMON:
6904       /* Common symbols less than the GP size are automatically
6905          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
6906       if (asym->value > elf_gp_size (abfd)
6907           || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6908           || IRIX_COMPAT (abfd) == ict_irix6)
6909         break;
6910       /* Fall through.  */
6911     case SHN_MIPS_SCOMMON:
6912       if (mips_elf_scom_section.name == NULL)
6913         {
6914           /* Initialize the small common section.  */
6915           mips_elf_scom_section.name = ".scommon";
6916           mips_elf_scom_section.flags = SEC_IS_COMMON;
6917           mips_elf_scom_section.output_section = &mips_elf_scom_section;
6918           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6919           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6920           mips_elf_scom_symbol.name = ".scommon";
6921           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6922           mips_elf_scom_symbol.section = &mips_elf_scom_section;
6923           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6924         }
6925       asym->section = &mips_elf_scom_section;
6926       asym->value = elfsym->internal_elf_sym.st_size;
6927       break;
6928
6929     case SHN_MIPS_SUNDEFINED:
6930       asym->section = bfd_und_section_ptr;
6931       break;
6932
6933     case SHN_MIPS_TEXT:
6934       {
6935         asection *section = bfd_get_section_by_name (abfd, ".text");
6936
6937         if (section != NULL)
6938           {
6939             asym->section = section;
6940             /* MIPS_TEXT is a bit special, the address is not an offset
6941                to the base of the .text section.  So substract the section
6942                base address to make it an offset.  */
6943             asym->value -= section->vma;
6944           }
6945       }
6946       break;
6947
6948     case SHN_MIPS_DATA:
6949       {
6950         asection *section = bfd_get_section_by_name (abfd, ".data");
6951
6952         if (section != NULL)
6953           {
6954             asym->section = section;
6955             /* MIPS_DATA is a bit special, the address is not an offset
6956                to the base of the .data section.  So substract the section
6957                base address to make it an offset.  */
6958             asym->value -= section->vma;
6959           }
6960       }
6961       break;
6962     }
6963
6964   /* If this is an odd-valued function symbol, assume it's a MIPS16
6965      or microMIPS one.  */
6966   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6967       && (asym->value & 1) != 0)
6968     {
6969       asym->value--;
6970       if (MICROMIPS_P (abfd))
6971         elfsym->internal_elf_sym.st_other
6972           = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6973       else
6974         elfsym->internal_elf_sym.st_other
6975           = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6976     }
6977 }
6978 \f
6979 /* Implement elf_backend_eh_frame_address_size.  This differs from
6980    the default in the way it handles EABI64.
6981
6982    EABI64 was originally specified as an LP64 ABI, and that is what
6983    -mabi=eabi normally gives on a 64-bit target.  However, gcc has
6984    historically accepted the combination of -mabi=eabi and -mlong32,
6985    and this ILP32 variation has become semi-official over time.
6986    Both forms use elf32 and have pointer-sized FDE addresses.
6987
6988    If an EABI object was generated by GCC 4.0 or above, it will have
6989    an empty .gcc_compiled_longXX section, where XX is the size of longs
6990    in bits.  Unfortunately, ILP32 objects generated by earlier compilers
6991    have no special marking to distinguish them from LP64 objects.
6992
6993    We don't want users of the official LP64 ABI to be punished for the
6994    existence of the ILP32 variant, but at the same time, we don't want
6995    to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6996    We therefore take the following approach:
6997
6998       - If ABFD contains a .gcc_compiled_longXX section, use it to
6999         determine the pointer size.
7000
7001       - Otherwise check the type of the first relocation.  Assume that
7002         the LP64 ABI is being used if the relocation is of type R_MIPS_64.
7003
7004       - Otherwise punt.
7005
7006    The second check is enough to detect LP64 objects generated by pre-4.0
7007    compilers because, in the kind of output generated by those compilers,
7008    the first relocation will be associated with either a CIE personality
7009    routine or an FDE start address.  Furthermore, the compilers never
7010    used a special (non-pointer) encoding for this ABI.
7011
7012    Checking the relocation type should also be safe because there is no
7013    reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
7014    did so.  */
7015
7016 unsigned int
7017 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
7018 {
7019   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
7020     return 8;
7021   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
7022     {
7023       bfd_boolean long32_p, long64_p;
7024
7025       long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
7026       long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
7027       if (long32_p && long64_p)
7028         return 0;
7029       if (long32_p)
7030         return 4;
7031       if (long64_p)
7032         return 8;
7033
7034       if (sec->reloc_count > 0
7035           && elf_section_data (sec)->relocs != NULL
7036           && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
7037               == R_MIPS_64))
7038         return 8;
7039
7040       return 0;
7041     }
7042   return 4;
7043 }
7044 \f
7045 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
7046    relocations against two unnamed section symbols to resolve to the
7047    same address.  For example, if we have code like:
7048
7049         lw      $4,%got_disp(.data)($gp)
7050         lw      $25,%got_disp(.text)($gp)
7051         jalr    $25
7052
7053    then the linker will resolve both relocations to .data and the program
7054    will jump there rather than to .text.
7055
7056    We can work around this problem by giving names to local section symbols.
7057    This is also what the MIPSpro tools do.  */
7058
7059 bfd_boolean
7060 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
7061 {
7062   return SGI_COMPAT (abfd);
7063 }
7064 \f
7065 /* Work over a section just before writing it out.  This routine is
7066    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
7067    sections that need the SHF_MIPS_GPREL flag by name; there has to be
7068    a better way.  */
7069
7070 bfd_boolean
7071 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
7072 {
7073   if (hdr->sh_type == SHT_MIPS_REGINFO
7074       && hdr->sh_size > 0)
7075     {
7076       bfd_byte buf[4];
7077
7078       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
7079       BFD_ASSERT (hdr->contents == NULL);
7080
7081       if (bfd_seek (abfd,
7082                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
7083                     SEEK_SET) != 0)
7084         return FALSE;
7085       H_PUT_32 (abfd, elf_gp (abfd), buf);
7086       if (bfd_bwrite (buf, 4, abfd) != 4)
7087         return FALSE;
7088     }
7089
7090   if (hdr->sh_type == SHT_MIPS_OPTIONS
7091       && hdr->bfd_section != NULL
7092       && mips_elf_section_data (hdr->bfd_section) != NULL
7093       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
7094     {
7095       bfd_byte *contents, *l, *lend;
7096
7097       /* We stored the section contents in the tdata field in the
7098          set_section_contents routine.  We save the section contents
7099          so that we don't have to read them again.
7100          At this point we know that elf_gp is set, so we can look
7101          through the section contents to see if there is an
7102          ODK_REGINFO structure.  */
7103
7104       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
7105       l = contents;
7106       lend = contents + hdr->sh_size;
7107       while (l + sizeof (Elf_External_Options) <= lend)
7108         {
7109           Elf_Internal_Options intopt;
7110
7111           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7112                                         &intopt);
7113           if (intopt.size < sizeof (Elf_External_Options))
7114             {
7115               _bfd_error_handler
7116                 /* xgettext:c-format */
7117                 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7118                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7119               break;
7120             }
7121           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7122             {
7123               bfd_byte buf[8];
7124
7125               if (bfd_seek (abfd,
7126                             (hdr->sh_offset
7127                              + (l - contents)
7128                              + sizeof (Elf_External_Options)
7129                              + (sizeof (Elf64_External_RegInfo) - 8)),
7130                              SEEK_SET) != 0)
7131                 return FALSE;
7132               H_PUT_64 (abfd, elf_gp (abfd), buf);
7133               if (bfd_bwrite (buf, 8, abfd) != 8)
7134                 return FALSE;
7135             }
7136           else if (intopt.kind == ODK_REGINFO)
7137             {
7138               bfd_byte buf[4];
7139
7140               if (bfd_seek (abfd,
7141                             (hdr->sh_offset
7142                              + (l - contents)
7143                              + sizeof (Elf_External_Options)
7144                              + (sizeof (Elf32_External_RegInfo) - 4)),
7145                             SEEK_SET) != 0)
7146                 return FALSE;
7147               H_PUT_32 (abfd, elf_gp (abfd), buf);
7148               if (bfd_bwrite (buf, 4, abfd) != 4)
7149                 return FALSE;
7150             }
7151           l += intopt.size;
7152         }
7153     }
7154
7155   if (hdr->bfd_section != NULL)
7156     {
7157       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
7158
7159       /* .sbss is not handled specially here because the GNU/Linux
7160          prelinker can convert .sbss from NOBITS to PROGBITS and
7161          changing it back to NOBITS breaks the binary.  The entry in
7162          _bfd_mips_elf_special_sections will ensure the correct flags
7163          are set on .sbss if BFD creates it without reading it from an
7164          input file, and without special handling here the flags set
7165          on it in an input file will be followed.  */
7166       if (strcmp (name, ".sdata") == 0
7167           || strcmp (name, ".lit8") == 0
7168           || strcmp (name, ".lit4") == 0)
7169         hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7170       else if (strcmp (name, ".srdata") == 0)
7171         hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
7172       else if (strcmp (name, ".compact_rel") == 0)
7173         hdr->sh_flags = 0;
7174       else if (strcmp (name, ".rtproc") == 0)
7175         {
7176           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
7177             {
7178               unsigned int adjust;
7179
7180               adjust = hdr->sh_size % hdr->sh_addralign;
7181               if (adjust != 0)
7182                 hdr->sh_size += hdr->sh_addralign - adjust;
7183             }
7184         }
7185     }
7186
7187   return TRUE;
7188 }
7189
7190 /* Handle a MIPS specific section when reading an object file.  This
7191    is called when elfcode.h finds a section with an unknown type.
7192    This routine supports both the 32-bit and 64-bit ELF ABI.
7193
7194    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
7195    how to.  */
7196
7197 bfd_boolean
7198 _bfd_mips_elf_section_from_shdr (bfd *abfd,
7199                                  Elf_Internal_Shdr *hdr,
7200                                  const char *name,
7201                                  int shindex)
7202 {
7203   flagword flags = 0;
7204
7205   /* There ought to be a place to keep ELF backend specific flags, but
7206      at the moment there isn't one.  We just keep track of the
7207      sections by their name, instead.  Fortunately, the ABI gives
7208      suggested names for all the MIPS specific sections, so we will
7209      probably get away with this.  */
7210   switch (hdr->sh_type)
7211     {
7212     case SHT_MIPS_LIBLIST:
7213       if (strcmp (name, ".liblist") != 0)
7214         return FALSE;
7215       break;
7216     case SHT_MIPS_MSYM:
7217       if (strcmp (name, ".msym") != 0)
7218         return FALSE;
7219       break;
7220     case SHT_MIPS_CONFLICT:
7221       if (strcmp (name, ".conflict") != 0)
7222         return FALSE;
7223       break;
7224     case SHT_MIPS_GPTAB:
7225       if (! CONST_STRNEQ (name, ".gptab."))
7226         return FALSE;
7227       break;
7228     case SHT_MIPS_UCODE:
7229       if (strcmp (name, ".ucode") != 0)
7230         return FALSE;
7231       break;
7232     case SHT_MIPS_DEBUG:
7233       if (strcmp (name, ".mdebug") != 0)
7234         return FALSE;
7235       flags = SEC_DEBUGGING;
7236       break;
7237     case SHT_MIPS_REGINFO:
7238       if (strcmp (name, ".reginfo") != 0
7239           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
7240         return FALSE;
7241       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7242       break;
7243     case SHT_MIPS_IFACE:
7244       if (strcmp (name, ".MIPS.interfaces") != 0)
7245         return FALSE;
7246       break;
7247     case SHT_MIPS_CONTENT:
7248       if (! CONST_STRNEQ (name, ".MIPS.content"))
7249         return FALSE;
7250       break;
7251     case SHT_MIPS_OPTIONS:
7252       if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7253         return FALSE;
7254       break;
7255     case SHT_MIPS_ABIFLAGS:
7256       if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name))
7257         return FALSE;
7258       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7259       break;
7260     case SHT_MIPS_DWARF:
7261       if (! CONST_STRNEQ (name, ".debug_")
7262           && ! CONST_STRNEQ (name, ".zdebug_"))
7263         return FALSE;
7264       break;
7265     case SHT_MIPS_SYMBOL_LIB:
7266       if (strcmp (name, ".MIPS.symlib") != 0)
7267         return FALSE;
7268       break;
7269     case SHT_MIPS_EVENTS:
7270       if (! CONST_STRNEQ (name, ".MIPS.events")
7271           && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
7272         return FALSE;
7273       break;
7274     default:
7275       break;
7276     }
7277
7278   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7279     return FALSE;
7280
7281   if (flags)
7282     {
7283       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
7284                                    (bfd_get_section_flags (abfd,
7285                                                            hdr->bfd_section)
7286                                     | flags)))
7287         return FALSE;
7288     }
7289
7290   if (hdr->sh_type == SHT_MIPS_ABIFLAGS)
7291     {
7292       Elf_External_ABIFlags_v0 ext;
7293
7294       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7295                                       &ext, 0, sizeof ext))
7296         return FALSE;
7297       bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext,
7298                                         &mips_elf_tdata (abfd)->abiflags);
7299       if (mips_elf_tdata (abfd)->abiflags.version != 0)
7300         return FALSE;
7301       mips_elf_tdata (abfd)->abiflags_valid = TRUE;
7302     }
7303
7304   /* FIXME: We should record sh_info for a .gptab section.  */
7305
7306   /* For a .reginfo section, set the gp value in the tdata information
7307      from the contents of this section.  We need the gp value while
7308      processing relocs, so we just get it now.  The .reginfo section
7309      is not used in the 64-bit MIPS ELF ABI.  */
7310   if (hdr->sh_type == SHT_MIPS_REGINFO)
7311     {
7312       Elf32_External_RegInfo ext;
7313       Elf32_RegInfo s;
7314
7315       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7316                                       &ext, 0, sizeof ext))
7317         return FALSE;
7318       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
7319       elf_gp (abfd) = s.ri_gp_value;
7320     }
7321
7322   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7323      set the gp value based on what we find.  We may see both
7324      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7325      they should agree.  */
7326   if (hdr->sh_type == SHT_MIPS_OPTIONS)
7327     {
7328       bfd_byte *contents, *l, *lend;
7329
7330       contents = bfd_malloc (hdr->sh_size);
7331       if (contents == NULL)
7332         return FALSE;
7333       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
7334                                       0, hdr->sh_size))
7335         {
7336           free (contents);
7337           return FALSE;
7338         }
7339       l = contents;
7340       lend = contents + hdr->sh_size;
7341       while (l + sizeof (Elf_External_Options) <= lend)
7342         {
7343           Elf_Internal_Options intopt;
7344
7345           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7346                                         &intopt);
7347           if (intopt.size < sizeof (Elf_External_Options))
7348             {
7349               _bfd_error_handler
7350                 /* xgettext:c-format */
7351                 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7352                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7353               break;
7354             }
7355           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7356             {
7357               Elf64_Internal_RegInfo intreg;
7358
7359               bfd_mips_elf64_swap_reginfo_in
7360                 (abfd,
7361                  ((Elf64_External_RegInfo *)
7362                   (l + sizeof (Elf_External_Options))),
7363                  &intreg);
7364               elf_gp (abfd) = intreg.ri_gp_value;
7365             }
7366           else if (intopt.kind == ODK_REGINFO)
7367             {
7368               Elf32_RegInfo intreg;
7369
7370               bfd_mips_elf32_swap_reginfo_in
7371                 (abfd,
7372                  ((Elf32_External_RegInfo *)
7373                   (l + sizeof (Elf_External_Options))),
7374                  &intreg);
7375               elf_gp (abfd) = intreg.ri_gp_value;
7376             }
7377           l += intopt.size;
7378         }
7379       free (contents);
7380     }
7381
7382   return TRUE;
7383 }
7384
7385 /* Set the correct type for a MIPS ELF section.  We do this by the
7386    section name, which is a hack, but ought to work.  This routine is
7387    used by both the 32-bit and the 64-bit ABI.  */
7388
7389 bfd_boolean
7390 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
7391 {
7392   const char *name = bfd_get_section_name (abfd, sec);
7393
7394   if (strcmp (name, ".liblist") == 0)
7395     {
7396       hdr->sh_type = SHT_MIPS_LIBLIST;
7397       hdr->sh_info = sec->size / sizeof (Elf32_Lib);
7398       /* The sh_link field is set in final_write_processing.  */
7399     }
7400   else if (strcmp (name, ".conflict") == 0)
7401     hdr->sh_type = SHT_MIPS_CONFLICT;
7402   else if (CONST_STRNEQ (name, ".gptab."))
7403     {
7404       hdr->sh_type = SHT_MIPS_GPTAB;
7405       hdr->sh_entsize = sizeof (Elf32_External_gptab);
7406       /* The sh_info field is set in final_write_processing.  */
7407     }
7408   else if (strcmp (name, ".ucode") == 0)
7409     hdr->sh_type = SHT_MIPS_UCODE;
7410   else if (strcmp (name, ".mdebug") == 0)
7411     {
7412       hdr->sh_type = SHT_MIPS_DEBUG;
7413       /* In a shared object on IRIX 5.3, the .mdebug section has an
7414          entsize of 0.  FIXME: Does this matter?  */
7415       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
7416         hdr->sh_entsize = 0;
7417       else
7418         hdr->sh_entsize = 1;
7419     }
7420   else if (strcmp (name, ".reginfo") == 0)
7421     {
7422       hdr->sh_type = SHT_MIPS_REGINFO;
7423       /* In a shared object on IRIX 5.3, the .reginfo section has an
7424          entsize of 0x18.  FIXME: Does this matter?  */
7425       if (SGI_COMPAT (abfd))
7426         {
7427           if ((abfd->flags & DYNAMIC) != 0)
7428             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7429           else
7430             hdr->sh_entsize = 1;
7431         }
7432       else
7433         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7434     }
7435   else if (SGI_COMPAT (abfd)
7436            && (strcmp (name, ".hash") == 0
7437                || strcmp (name, ".dynamic") == 0
7438                || strcmp (name, ".dynstr") == 0))
7439     {
7440       if (SGI_COMPAT (abfd))
7441         hdr->sh_entsize = 0;
7442 #if 0
7443       /* This isn't how the IRIX6 linker behaves.  */
7444       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
7445 #endif
7446     }
7447   else if (strcmp (name, ".got") == 0
7448            || strcmp (name, ".srdata") == 0
7449            || strcmp (name, ".sdata") == 0
7450            || strcmp (name, ".sbss") == 0
7451            || strcmp (name, ".lit4") == 0
7452            || strcmp (name, ".lit8") == 0)
7453     hdr->sh_flags |= SHF_MIPS_GPREL;
7454   else if (strcmp (name, ".MIPS.interfaces") == 0)
7455     {
7456       hdr->sh_type = SHT_MIPS_IFACE;
7457       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7458     }
7459   else if (CONST_STRNEQ (name, ".MIPS.content"))
7460     {
7461       hdr->sh_type = SHT_MIPS_CONTENT;
7462       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7463       /* The sh_info field is set in final_write_processing.  */
7464     }
7465   else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7466     {
7467       hdr->sh_type = SHT_MIPS_OPTIONS;
7468       hdr->sh_entsize = 1;
7469       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7470     }
7471   else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
7472     {
7473       hdr->sh_type = SHT_MIPS_ABIFLAGS;
7474       hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
7475     }
7476   else if (CONST_STRNEQ (name, ".debug_")
7477            || CONST_STRNEQ (name, ".zdebug_"))
7478     {
7479       hdr->sh_type = SHT_MIPS_DWARF;
7480
7481       /* Irix facilities such as libexc expect a single .debug_frame
7482          per executable, the system ones have NOSTRIP set and the linker
7483          doesn't merge sections with different flags so ...  */
7484       if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
7485         hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7486     }
7487   else if (strcmp (name, ".MIPS.symlib") == 0)
7488     {
7489       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
7490       /* The sh_link and sh_info fields are set in
7491          final_write_processing.  */
7492     }
7493   else if (CONST_STRNEQ (name, ".MIPS.events")
7494            || CONST_STRNEQ (name, ".MIPS.post_rel"))
7495     {
7496       hdr->sh_type = SHT_MIPS_EVENTS;
7497       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7498       /* The sh_link field is set in final_write_processing.  */
7499     }
7500   else if (strcmp (name, ".msym") == 0)
7501     {
7502       hdr->sh_type = SHT_MIPS_MSYM;
7503       hdr->sh_flags |= SHF_ALLOC;
7504       hdr->sh_entsize = 8;
7505     }
7506
7507   /* The generic elf_fake_sections will set up REL_HDR using the default
7508    kind of relocations.  We used to set up a second header for the
7509    non-default kind of relocations here, but only NewABI would use
7510    these, and the IRIX ld doesn't like resulting empty RELA sections.
7511    Thus we create those header only on demand now.  */
7512
7513   return TRUE;
7514 }
7515
7516 /* Given a BFD section, try to locate the corresponding ELF section
7517    index.  This is used by both the 32-bit and the 64-bit ABI.
7518    Actually, it's not clear to me that the 64-bit ABI supports these,
7519    but for non-PIC objects we will certainly want support for at least
7520    the .scommon section.  */
7521
7522 bfd_boolean
7523 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7524                                         asection *sec, int *retval)
7525 {
7526   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
7527     {
7528       *retval = SHN_MIPS_SCOMMON;
7529       return TRUE;
7530     }
7531   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
7532     {
7533       *retval = SHN_MIPS_ACOMMON;
7534       return TRUE;
7535     }
7536   return FALSE;
7537 }
7538 \f
7539 /* Hook called by the linker routine which adds symbols from an object
7540    file.  We must handle the special MIPS section numbers here.  */
7541
7542 bfd_boolean
7543 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
7544                                Elf_Internal_Sym *sym, const char **namep,
7545                                flagword *flagsp ATTRIBUTE_UNUSED,
7546                                asection **secp, bfd_vma *valp)
7547 {
7548   if (SGI_COMPAT (abfd)
7549       && (abfd->flags & DYNAMIC) != 0
7550       && strcmp (*namep, "_rld_new_interface") == 0)
7551     {
7552       /* Skip IRIX5 rld entry name.  */
7553       *namep = NULL;
7554       return TRUE;
7555     }
7556
7557   /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7558      a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
7559      by setting a DT_NEEDED for the shared object.  Since _gp_disp is
7560      a magic symbol resolved by the linker, we ignore this bogus definition
7561      of _gp_disp.  New ABI objects do not suffer from this problem so this
7562      is not done for them. */
7563   if (!NEWABI_P(abfd)
7564       && (sym->st_shndx == SHN_ABS)
7565       && (strcmp (*namep, "_gp_disp") == 0))
7566     {
7567       *namep = NULL;
7568       return TRUE;
7569     }
7570
7571   switch (sym->st_shndx)
7572     {
7573     case SHN_COMMON:
7574       /* Common symbols less than the GP size are automatically
7575          treated as SHN_MIPS_SCOMMON symbols.  */
7576       if (sym->st_size > elf_gp_size (abfd)
7577           || ELF_ST_TYPE (sym->st_info) == STT_TLS
7578           || IRIX_COMPAT (abfd) == ict_irix6)
7579         break;
7580       /* Fall through.  */
7581     case SHN_MIPS_SCOMMON:
7582       *secp = bfd_make_section_old_way (abfd, ".scommon");
7583       (*secp)->flags |= SEC_IS_COMMON;
7584       *valp = sym->st_size;
7585       break;
7586
7587     case SHN_MIPS_TEXT:
7588       /* This section is used in a shared object.  */
7589       if (mips_elf_tdata (abfd)->elf_text_section == NULL)
7590         {
7591           asymbol *elf_text_symbol;
7592           asection *elf_text_section;
7593           bfd_size_type amt = sizeof (asection);
7594
7595           elf_text_section = bfd_zalloc (abfd, amt);
7596           if (elf_text_section == NULL)
7597             return FALSE;
7598
7599           amt = sizeof (asymbol);
7600           elf_text_symbol = bfd_zalloc (abfd, amt);
7601           if (elf_text_symbol == NULL)
7602             return FALSE;
7603
7604           /* Initialize the section.  */
7605
7606           mips_elf_tdata (abfd)->elf_text_section = elf_text_section;
7607           mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7608
7609           elf_text_section->symbol = elf_text_symbol;
7610           elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol;
7611
7612           elf_text_section->name = ".text";
7613           elf_text_section->flags = SEC_NO_FLAGS;
7614           elf_text_section->output_section = NULL;
7615           elf_text_section->owner = abfd;
7616           elf_text_symbol->name = ".text";
7617           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7618           elf_text_symbol->section = elf_text_section;
7619         }
7620       /* This code used to do *secp = bfd_und_section_ptr if
7621          bfd_link_pic (info).  I don't know why, and that doesn't make sense,
7622          so I took it out.  */
7623       *secp = mips_elf_tdata (abfd)->elf_text_section;
7624       break;
7625
7626     case SHN_MIPS_ACOMMON:
7627       /* Fall through. XXX Can we treat this as allocated data?  */
7628     case SHN_MIPS_DATA:
7629       /* This section is used in a shared object.  */
7630       if (mips_elf_tdata (abfd)->elf_data_section == NULL)
7631         {
7632           asymbol *elf_data_symbol;
7633           asection *elf_data_section;
7634           bfd_size_type amt = sizeof (asection);
7635
7636           elf_data_section = bfd_zalloc (abfd, amt);
7637           if (elf_data_section == NULL)
7638             return FALSE;
7639
7640           amt = sizeof (asymbol);
7641           elf_data_symbol = bfd_zalloc (abfd, amt);
7642           if (elf_data_symbol == NULL)
7643             return FALSE;
7644
7645           /* Initialize the section.  */
7646
7647           mips_elf_tdata (abfd)->elf_data_section = elf_data_section;
7648           mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7649
7650           elf_data_section->symbol = elf_data_symbol;
7651           elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol;
7652
7653           elf_data_section->name = ".data";
7654           elf_data_section->flags = SEC_NO_FLAGS;
7655           elf_data_section->output_section = NULL;
7656           elf_data_section->owner = abfd;
7657           elf_data_symbol->name = ".data";
7658           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7659           elf_data_symbol->section = elf_data_section;
7660         }
7661       /* This code used to do *secp = bfd_und_section_ptr if
7662          bfd_link_pic (info).  I don't know why, and that doesn't make sense,
7663          so I took it out.  */
7664       *secp = mips_elf_tdata (abfd)->elf_data_section;
7665       break;
7666
7667     case SHN_MIPS_SUNDEFINED:
7668       *secp = bfd_und_section_ptr;
7669       break;
7670     }
7671
7672   if (SGI_COMPAT (abfd)
7673       && ! bfd_link_pic (info)
7674       && info->output_bfd->xvec == abfd->xvec
7675       && strcmp (*namep, "__rld_obj_head") == 0)
7676     {
7677       struct elf_link_hash_entry *h;
7678       struct bfd_link_hash_entry *bh;
7679
7680       /* Mark __rld_obj_head as dynamic.  */
7681       bh = NULL;
7682       if (! (_bfd_generic_link_add_one_symbol
7683              (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7684               get_elf_backend_data (abfd)->collect, &bh)))
7685         return FALSE;
7686
7687       h = (struct elf_link_hash_entry *) bh;
7688       h->non_elf = 0;
7689       h->def_regular = 1;
7690       h->type = STT_OBJECT;
7691
7692       if (! bfd_elf_link_record_dynamic_symbol (info, h))
7693         return FALSE;
7694
7695       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7696       mips_elf_hash_table (info)->rld_symbol = h;
7697     }
7698
7699   /* If this is a mips16 text symbol, add 1 to the value to make it
7700      odd.  This will cause something like .word SYM to come up with
7701      the right value when it is loaded into the PC.  */
7702   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7703     ++*valp;
7704
7705   return TRUE;
7706 }
7707
7708 /* This hook function is called before the linker writes out a global
7709    symbol.  We mark symbols as small common if appropriate.  This is
7710    also where we undo the increment of the value for a mips16 symbol.  */
7711
7712 int
7713 _bfd_mips_elf_link_output_symbol_hook
7714   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7715    const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7716    asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7717 {
7718   /* If we see a common symbol, which implies a relocatable link, then
7719      if a symbol was small common in an input file, mark it as small
7720      common in the output file.  */
7721   if (sym->st_shndx == SHN_COMMON
7722       && strcmp (input_sec->name, ".scommon") == 0)
7723     sym->st_shndx = SHN_MIPS_SCOMMON;
7724
7725   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7726     sym->st_value &= ~1;
7727
7728   return 1;
7729 }
7730 \f
7731 /* Functions for the dynamic linker.  */
7732
7733 /* Create dynamic sections when linking against a dynamic object.  */
7734
7735 bfd_boolean
7736 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7737 {
7738   struct elf_link_hash_entry *h;
7739   struct bfd_link_hash_entry *bh;
7740   flagword flags;
7741   register asection *s;
7742   const char * const *namep;
7743   struct mips_elf_link_hash_table *htab;
7744
7745   htab = mips_elf_hash_table (info);
7746   BFD_ASSERT (htab != NULL);
7747
7748   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7749            | SEC_LINKER_CREATED | SEC_READONLY);
7750
7751   /* The psABI requires a read-only .dynamic section, but the VxWorks
7752      EABI doesn't.  */
7753   if (!htab->is_vxworks)
7754     {
7755       s = bfd_get_linker_section (abfd, ".dynamic");
7756       if (s != NULL)
7757         {
7758           if (! bfd_set_section_flags (abfd, s, flags))
7759             return FALSE;
7760         }
7761     }
7762
7763   /* We need to create .got section.  */
7764   if (!mips_elf_create_got_section (abfd, info))
7765     return FALSE;
7766
7767   if (! mips_elf_rel_dyn_section (info, TRUE))
7768     return FALSE;
7769
7770   /* Create .stub section.  */
7771   s = bfd_make_section_anyway_with_flags (abfd,
7772                                           MIPS_ELF_STUB_SECTION_NAME (abfd),
7773                                           flags | SEC_CODE);
7774   if (s == NULL
7775       || ! bfd_set_section_alignment (abfd, s,
7776                                       MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7777     return FALSE;
7778   htab->sstubs = s;
7779
7780   if (!mips_elf_hash_table (info)->use_rld_obj_head
7781       && bfd_link_executable (info)
7782       && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7783     {
7784       s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7785                                               flags &~ (flagword) SEC_READONLY);
7786       if (s == NULL
7787           || ! bfd_set_section_alignment (abfd, s,
7788                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7789         return FALSE;
7790     }
7791
7792   /* On IRIX5, we adjust add some additional symbols and change the
7793      alignments of several sections.  There is no ABI documentation
7794      indicating that this is necessary on IRIX6, nor any evidence that
7795      the linker takes such action.  */
7796   if (IRIX_COMPAT (abfd) == ict_irix5)
7797     {
7798       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7799         {
7800           bh = NULL;
7801           if (! (_bfd_generic_link_add_one_symbol
7802                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7803                   NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7804             return FALSE;
7805
7806           h = (struct elf_link_hash_entry *) bh;
7807           h->non_elf = 0;
7808           h->def_regular = 1;
7809           h->type = STT_SECTION;
7810
7811           if (! bfd_elf_link_record_dynamic_symbol (info, h))
7812             return FALSE;
7813         }
7814
7815       /* We need to create a .compact_rel section.  */
7816       if (SGI_COMPAT (abfd))
7817         {
7818           if (!mips_elf_create_compact_rel_section (abfd, info))
7819             return FALSE;
7820         }
7821
7822       /* Change alignments of some sections.  */
7823       s = bfd_get_linker_section (abfd, ".hash");
7824       if (s != NULL)
7825         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7826
7827       s = bfd_get_linker_section (abfd, ".dynsym");
7828       if (s != NULL)
7829         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7830
7831       s = bfd_get_linker_section (abfd, ".dynstr");
7832       if (s != NULL)
7833         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7834
7835       /* ??? */
7836       s = bfd_get_section_by_name (abfd, ".reginfo");
7837       if (s != NULL)
7838         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7839
7840       s = bfd_get_linker_section (abfd, ".dynamic");
7841       if (s != NULL)
7842         (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7843     }
7844
7845   if (bfd_link_executable (info))
7846     {
7847       const char *name;
7848
7849       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7850       bh = NULL;
7851       if (!(_bfd_generic_link_add_one_symbol
7852             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7853              NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7854         return FALSE;
7855
7856       h = (struct elf_link_hash_entry *) bh;
7857       h->non_elf = 0;
7858       h->def_regular = 1;
7859       h->type = STT_SECTION;
7860
7861       if (! bfd_elf_link_record_dynamic_symbol (info, h))
7862         return FALSE;
7863
7864       if (! mips_elf_hash_table (info)->use_rld_obj_head)
7865         {
7866           /* __rld_map is a four byte word located in the .data section
7867              and is filled in by the rtld to contain a pointer to
7868              the _r_debug structure. Its symbol value will be set in
7869              _bfd_mips_elf_finish_dynamic_symbol.  */
7870           s = bfd_get_linker_section (abfd, ".rld_map");
7871           BFD_ASSERT (s != NULL);
7872
7873           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7874           bh = NULL;
7875           if (!(_bfd_generic_link_add_one_symbol
7876                 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7877                  get_elf_backend_data (abfd)->collect, &bh)))
7878             return FALSE;
7879
7880           h = (struct elf_link_hash_entry *) bh;
7881           h->non_elf = 0;
7882           h->def_regular = 1;
7883           h->type = STT_OBJECT;
7884
7885           if (! bfd_elf_link_record_dynamic_symbol (info, h))
7886             return FALSE;
7887           mips_elf_hash_table (info)->rld_symbol = h;
7888         }
7889     }
7890
7891   /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7892      Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol.  */
7893   if (!_bfd_elf_create_dynamic_sections (abfd, info))
7894     return FALSE;
7895
7896   /* Cache the sections created above.  */
7897   htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
7898   if (htab->is_vxworks)
7899     htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
7900   if (!htab->sdynbss
7901       || (htab->is_vxworks && !htab->srelbss && !bfd_link_pic (info))
7902       || !htab->root.srelplt
7903       || !htab->root.splt)
7904     abort ();
7905
7906   /* Do the usual VxWorks handling.  */
7907   if (htab->is_vxworks
7908       && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7909     return FALSE;
7910
7911   return TRUE;
7912 }
7913 \f
7914 /* Return true if relocation REL against section SEC is a REL rather than
7915    RELA relocation.  RELOCS is the first relocation in the section and
7916    ABFD is the bfd that contains SEC.  */
7917
7918 static bfd_boolean
7919 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7920                            const Elf_Internal_Rela *relocs,
7921                            const Elf_Internal_Rela *rel)
7922 {
7923   Elf_Internal_Shdr *rel_hdr;
7924   const struct elf_backend_data *bed;
7925
7926   /* To determine which flavor of relocation this is, we depend on the
7927      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
7928   rel_hdr = elf_section_data (sec)->rel.hdr;
7929   if (rel_hdr == NULL)
7930     return FALSE;
7931   bed = get_elf_backend_data (abfd);
7932   return ((size_t) (rel - relocs)
7933           < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7934 }
7935
7936 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7937    HOWTO is the relocation's howto and CONTENTS points to the contents
7938    of the section that REL is against.  */
7939
7940 static bfd_vma
7941 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7942                           reloc_howto_type *howto, bfd_byte *contents)
7943 {
7944   bfd_byte *location;
7945   unsigned int r_type;
7946   bfd_vma addend;
7947   bfd_vma bytes;
7948
7949   r_type = ELF_R_TYPE (abfd, rel->r_info);
7950   location = contents + rel->r_offset;
7951
7952   /* Get the addend, which is stored in the input file.  */
7953   _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7954   bytes = mips_elf_obtain_contents (howto, rel, abfd, contents);
7955   _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7956
7957   addend = bytes & howto->src_mask;
7958
7959   /* Shift is 2, unusually, for microMIPS JALX.  Adjust the addend
7960      accordingly.  */
7961   if (r_type == R_MICROMIPS_26_S1 && (bytes >> 26) == 0x3c)
7962     addend <<= 1;
7963
7964   return addend;
7965 }
7966
7967 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7968    and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
7969    and update *ADDEND with the final addend.  Return true on success
7970    or false if the LO16 could not be found.  RELEND is the exclusive
7971    upper bound on the relocations for REL's section.  */
7972
7973 static bfd_boolean
7974 mips_elf_add_lo16_rel_addend (bfd *abfd,
7975                               const Elf_Internal_Rela *rel,
7976                               const Elf_Internal_Rela *relend,
7977                               bfd_byte *contents, bfd_vma *addend)
7978 {
7979   unsigned int r_type, lo16_type;
7980   const Elf_Internal_Rela *lo16_relocation;
7981   reloc_howto_type *lo16_howto;
7982   bfd_vma l;
7983
7984   r_type = ELF_R_TYPE (abfd, rel->r_info);
7985   if (mips16_reloc_p (r_type))
7986     lo16_type = R_MIPS16_LO16;
7987   else if (micromips_reloc_p (r_type))
7988     lo16_type = R_MICROMIPS_LO16;
7989   else if (r_type == R_MIPS_PCHI16)
7990     lo16_type = R_MIPS_PCLO16;
7991   else
7992     lo16_type = R_MIPS_LO16;
7993
7994   /* The combined value is the sum of the HI16 addend, left-shifted by
7995      sixteen bits, and the LO16 addend, sign extended.  (Usually, the
7996      code does a `lui' of the HI16 value, and then an `addiu' of the
7997      LO16 value.)
7998
7999      Scan ahead to find a matching LO16 relocation.
8000
8001      According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8002      be immediately following.  However, for the IRIX6 ABI, the next
8003      relocation may be a composed relocation consisting of several
8004      relocations for the same address.  In that case, the R_MIPS_LO16
8005      relocation may occur as one of these.  We permit a similar
8006      extension in general, as that is useful for GCC.
8007
8008      In some cases GCC dead code elimination removes the LO16 but keeps
8009      the corresponding HI16.  This is strictly speaking a violation of
8010      the ABI but not immediately harmful.  */
8011   lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
8012   if (lo16_relocation == NULL)
8013     return FALSE;
8014
8015   /* Obtain the addend kept there.  */
8016   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
8017   l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
8018
8019   l <<= lo16_howto->rightshift;
8020   l = _bfd_mips_elf_sign_extend (l, 16);
8021
8022   *addend <<= 16;
8023   *addend += l;
8024   return TRUE;
8025 }
8026
8027 /* Try to read the contents of section SEC in bfd ABFD.  Return true and
8028    store the contents in *CONTENTS on success.  Assume that *CONTENTS
8029    already holds the contents if it is nonull on entry.  */
8030
8031 static bfd_boolean
8032 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
8033 {
8034   if (*contents)
8035     return TRUE;
8036
8037   /* Get cached copy if it exists.  */
8038   if (elf_section_data (sec)->this_hdr.contents != NULL)
8039     {
8040       *contents = elf_section_data (sec)->this_hdr.contents;
8041       return TRUE;
8042     }
8043
8044   return bfd_malloc_and_get_section (abfd, sec, contents);
8045 }
8046
8047 /* Make a new PLT record to keep internal data.  */
8048
8049 static struct plt_entry *
8050 mips_elf_make_plt_record (bfd *abfd)
8051 {
8052   struct plt_entry *entry;
8053
8054   entry = bfd_zalloc (abfd, sizeof (*entry));
8055   if (entry == NULL)
8056     return NULL;
8057
8058   entry->stub_offset = MINUS_ONE;
8059   entry->mips_offset = MINUS_ONE;
8060   entry->comp_offset = MINUS_ONE;
8061   entry->gotplt_index = MINUS_ONE;
8062   return entry;
8063 }
8064
8065 /* Look through the relocs for a section during the first phase, and
8066    allocate space in the global offset table and record the need for
8067    standard MIPS and compressed procedure linkage table entries.  */
8068
8069 bfd_boolean
8070 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
8071                             asection *sec, const Elf_Internal_Rela *relocs)
8072 {
8073   const char *name;
8074   bfd *dynobj;
8075   Elf_Internal_Shdr *symtab_hdr;
8076   struct elf_link_hash_entry **sym_hashes;
8077   size_t extsymoff;
8078   const Elf_Internal_Rela *rel;
8079   const Elf_Internal_Rela *rel_end;
8080   asection *sreloc;
8081   const struct elf_backend_data *bed;
8082   struct mips_elf_link_hash_table *htab;
8083   bfd_byte *contents;
8084   bfd_vma addend;
8085   reloc_howto_type *howto;
8086
8087   if (bfd_link_relocatable (info))
8088     return TRUE;
8089
8090   htab = mips_elf_hash_table (info);
8091   BFD_ASSERT (htab != NULL);
8092
8093   dynobj = elf_hash_table (info)->dynobj;
8094   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8095   sym_hashes = elf_sym_hashes (abfd);
8096   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8097
8098   bed = get_elf_backend_data (abfd);
8099   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
8100
8101   /* Check for the mips16 stub sections.  */
8102
8103   name = bfd_get_section_name (abfd, sec);
8104   if (FN_STUB_P (name))
8105     {
8106       unsigned long r_symndx;
8107
8108       /* Look at the relocation information to figure out which symbol
8109          this is for.  */
8110
8111       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8112       if (r_symndx == 0)
8113         {
8114           _bfd_error_handler
8115             /* xgettext:c-format */
8116             (_("%B: Warning: cannot determine the target function for"
8117                " stub section `%s'"),
8118              abfd, name);
8119           bfd_set_error (bfd_error_bad_value);
8120           return FALSE;
8121         }
8122
8123       if (r_symndx < extsymoff
8124           || sym_hashes[r_symndx - extsymoff] == NULL)
8125         {
8126           asection *o;
8127
8128           /* This stub is for a local symbol.  This stub will only be
8129              needed if there is some relocation in this BFD, other
8130              than a 16 bit function call, which refers to this symbol.  */
8131           for (o = abfd->sections; o != NULL; o = o->next)
8132             {
8133               Elf_Internal_Rela *sec_relocs;
8134               const Elf_Internal_Rela *r, *rend;
8135
8136               /* We can ignore stub sections when looking for relocs.  */
8137               if ((o->flags & SEC_RELOC) == 0
8138                   || o->reloc_count == 0
8139                   || section_allows_mips16_refs_p (o))
8140                 continue;
8141
8142               sec_relocs
8143                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8144                                              info->keep_memory);
8145               if (sec_relocs == NULL)
8146                 return FALSE;
8147
8148               rend = sec_relocs + o->reloc_count;
8149               for (r = sec_relocs; r < rend; r++)
8150                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8151                     && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
8152                   break;
8153
8154               if (elf_section_data (o)->relocs != sec_relocs)
8155                 free (sec_relocs);
8156
8157               if (r < rend)
8158                 break;
8159             }
8160
8161           if (o == NULL)
8162             {
8163               /* There is no non-call reloc for this stub, so we do
8164                  not need it.  Since this function is called before
8165                  the linker maps input sections to output sections, we
8166                  can easily discard it by setting the SEC_EXCLUDE
8167                  flag.  */
8168               sec->flags |= SEC_EXCLUDE;
8169               return TRUE;
8170             }
8171
8172           /* Record this stub in an array of local symbol stubs for
8173              this BFD.  */
8174           if (mips_elf_tdata (abfd)->local_stubs == NULL)
8175             {
8176               unsigned long symcount;
8177               asection **n;
8178               bfd_size_type amt;
8179
8180               if (elf_bad_symtab (abfd))
8181                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8182               else
8183                 symcount = symtab_hdr->sh_info;
8184               amt = symcount * sizeof (asection *);
8185               n = bfd_zalloc (abfd, amt);
8186               if (n == NULL)
8187                 return FALSE;
8188               mips_elf_tdata (abfd)->local_stubs = n;
8189             }
8190
8191           sec->flags |= SEC_KEEP;
8192           mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec;
8193
8194           /* We don't need to set mips16_stubs_seen in this case.
8195              That flag is used to see whether we need to look through
8196              the global symbol table for stubs.  We don't need to set
8197              it here, because we just have a local stub.  */
8198         }
8199       else
8200         {
8201           struct mips_elf_link_hash_entry *h;
8202
8203           h = ((struct mips_elf_link_hash_entry *)
8204                sym_hashes[r_symndx - extsymoff]);
8205
8206           while (h->root.root.type == bfd_link_hash_indirect
8207                  || h->root.root.type == bfd_link_hash_warning)
8208             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8209
8210           /* H is the symbol this stub is for.  */
8211
8212           /* If we already have an appropriate stub for this function, we
8213              don't need another one, so we can discard this one.  Since
8214              this function is called before the linker maps input sections
8215              to output sections, we can easily discard it by setting the
8216              SEC_EXCLUDE flag.  */
8217           if (h->fn_stub != NULL)
8218             {
8219               sec->flags |= SEC_EXCLUDE;
8220               return TRUE;
8221             }
8222
8223           sec->flags |= SEC_KEEP;
8224           h->fn_stub = sec;
8225           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8226         }
8227     }
8228   else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
8229     {
8230       unsigned long r_symndx;
8231       struct mips_elf_link_hash_entry *h;
8232       asection **loc;
8233
8234       /* Look at the relocation information to figure out which symbol
8235          this is for.  */
8236
8237       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8238       if (r_symndx == 0)
8239         {
8240           _bfd_error_handler
8241             /* xgettext:c-format */
8242             (_("%B: Warning: cannot determine the target function for"
8243                " stub section `%s'"),
8244              abfd, name);
8245           bfd_set_error (bfd_error_bad_value);
8246           return FALSE;
8247         }
8248
8249       if (r_symndx < extsymoff
8250           || sym_hashes[r_symndx - extsymoff] == NULL)
8251         {
8252           asection *o;
8253
8254           /* This stub is for a local symbol.  This stub will only be
8255              needed if there is some relocation (R_MIPS16_26) in this BFD
8256              that refers to this symbol.  */
8257           for (o = abfd->sections; o != NULL; o = o->next)
8258             {
8259               Elf_Internal_Rela *sec_relocs;
8260               const Elf_Internal_Rela *r, *rend;
8261
8262               /* We can ignore stub sections when looking for relocs.  */
8263               if ((o->flags & SEC_RELOC) == 0
8264                   || o->reloc_count == 0
8265                   || section_allows_mips16_refs_p (o))
8266                 continue;
8267
8268               sec_relocs
8269                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8270                                              info->keep_memory);
8271               if (sec_relocs == NULL)
8272                 return FALSE;
8273
8274               rend = sec_relocs + o->reloc_count;
8275               for (r = sec_relocs; r < rend; r++)
8276                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8277                     && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
8278                     break;
8279
8280               if (elf_section_data (o)->relocs != sec_relocs)
8281                 free (sec_relocs);
8282
8283               if (r < rend)
8284                 break;
8285             }
8286
8287           if (o == NULL)
8288             {
8289               /* There is no non-call reloc for this stub, so we do
8290                  not need it.  Since this function is called before
8291                  the linker maps input sections to output sections, we
8292                  can easily discard it by setting the SEC_EXCLUDE
8293                  flag.  */
8294               sec->flags |= SEC_EXCLUDE;
8295               return TRUE;
8296             }
8297
8298           /* Record this stub in an array of local symbol call_stubs for
8299              this BFD.  */
8300           if (mips_elf_tdata (abfd)->local_call_stubs == NULL)
8301             {
8302               unsigned long symcount;
8303               asection **n;
8304               bfd_size_type amt;
8305
8306               if (elf_bad_symtab (abfd))
8307                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8308               else
8309                 symcount = symtab_hdr->sh_info;
8310               amt = symcount * sizeof (asection *);
8311               n = bfd_zalloc (abfd, amt);
8312               if (n == NULL)
8313                 return FALSE;
8314               mips_elf_tdata (abfd)->local_call_stubs = n;
8315             }
8316
8317           sec->flags |= SEC_KEEP;
8318           mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
8319
8320           /* We don't need to set mips16_stubs_seen in this case.
8321              That flag is used to see whether we need to look through
8322              the global symbol table for stubs.  We don't need to set
8323              it here, because we just have a local stub.  */
8324         }
8325       else
8326         {
8327           h = ((struct mips_elf_link_hash_entry *)
8328                sym_hashes[r_symndx - extsymoff]);
8329
8330           /* H is the symbol this stub is for.  */
8331
8332           if (CALL_FP_STUB_P (name))
8333             loc = &h->call_fp_stub;
8334           else
8335             loc = &h->call_stub;
8336
8337           /* If we already have an appropriate stub for this function, we
8338              don't need another one, so we can discard this one.  Since
8339              this function is called before the linker maps input sections
8340              to output sections, we can easily discard it by setting the
8341              SEC_EXCLUDE flag.  */
8342           if (*loc != NULL)
8343             {
8344               sec->flags |= SEC_EXCLUDE;
8345               return TRUE;
8346             }
8347
8348           sec->flags |= SEC_KEEP;
8349           *loc = sec;
8350           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8351         }
8352     }
8353
8354   sreloc = NULL;
8355   contents = NULL;
8356   for (rel = relocs; rel < rel_end; ++rel)
8357     {
8358       unsigned long r_symndx;
8359       unsigned int r_type;
8360       struct elf_link_hash_entry *h;
8361       bfd_boolean can_make_dynamic_p;
8362       bfd_boolean call_reloc_p;
8363       bfd_boolean constrain_symbol_p;
8364
8365       r_symndx = ELF_R_SYM (abfd, rel->r_info);
8366       r_type = ELF_R_TYPE (abfd, rel->r_info);
8367
8368       if (r_symndx < extsymoff)
8369         h = NULL;
8370       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
8371         {
8372           _bfd_error_handler
8373             /* xgettext:c-format */
8374             (_("%B: Malformed reloc detected for section %s"),
8375              abfd, name);
8376           bfd_set_error (bfd_error_bad_value);
8377           return FALSE;
8378         }
8379       else
8380         {
8381           h = sym_hashes[r_symndx - extsymoff];
8382           if (h != NULL)
8383             {
8384               while (h->root.type == bfd_link_hash_indirect
8385                      || h->root.type == bfd_link_hash_warning)
8386                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8387
8388               /* PR15323, ref flags aren't set for references in the
8389                  same object.  */
8390               h->root.non_ir_ref = 1;
8391             }
8392         }
8393
8394       /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8395          relocation into a dynamic one.  */
8396       can_make_dynamic_p = FALSE;
8397
8398       /* Set CALL_RELOC_P to true if the relocation is for a call,
8399          and if pointer equality therefore doesn't matter.  */
8400       call_reloc_p = FALSE;
8401
8402       /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8403          into account when deciding how to define the symbol.
8404          Relocations in nonallocatable sections such as .pdr and
8405          .debug* should have no effect.  */
8406       constrain_symbol_p = ((sec->flags & SEC_ALLOC) != 0);
8407
8408       switch (r_type)
8409         {
8410         case R_MIPS_CALL16:
8411         case R_MIPS_CALL_HI16:
8412         case R_MIPS_CALL_LO16:
8413         case R_MIPS16_CALL16:
8414         case R_MICROMIPS_CALL16:
8415         case R_MICROMIPS_CALL_HI16:
8416         case R_MICROMIPS_CALL_LO16:
8417           call_reloc_p = TRUE;
8418           /* Fall through.  */
8419
8420         case R_MIPS_GOT16:
8421         case R_MIPS_GOT_HI16:
8422         case R_MIPS_GOT_LO16:
8423         case R_MIPS_GOT_PAGE:
8424         case R_MIPS_GOT_OFST:
8425         case R_MIPS_GOT_DISP:
8426         case R_MIPS_TLS_GOTTPREL:
8427         case R_MIPS_TLS_GD:
8428         case R_MIPS_TLS_LDM:
8429         case R_MIPS16_GOT16:
8430         case R_MIPS16_TLS_GOTTPREL:
8431         case R_MIPS16_TLS_GD:
8432         case R_MIPS16_TLS_LDM:
8433         case R_MICROMIPS_GOT16:
8434         case R_MICROMIPS_GOT_HI16:
8435         case R_MICROMIPS_GOT_LO16:
8436         case R_MICROMIPS_GOT_PAGE:
8437         case R_MICROMIPS_GOT_OFST:
8438         case R_MICROMIPS_GOT_DISP:
8439         case R_MICROMIPS_TLS_GOTTPREL:
8440         case R_MICROMIPS_TLS_GD:
8441         case R_MICROMIPS_TLS_LDM:
8442           if (dynobj == NULL)
8443             elf_hash_table (info)->dynobj = dynobj = abfd;
8444           if (!mips_elf_create_got_section (dynobj, info))
8445             return FALSE;
8446           if (htab->is_vxworks && !bfd_link_pic (info))
8447             {
8448               _bfd_error_handler
8449                 /* xgettext:c-format */
8450                 (_("%B: GOT reloc at 0x%lx not expected in executables"),
8451                  abfd, (unsigned long) rel->r_offset);
8452               bfd_set_error (bfd_error_bad_value);
8453               return FALSE;
8454             }
8455           can_make_dynamic_p = TRUE;
8456           break;
8457
8458         case R_MIPS_NONE:
8459         case R_MIPS_JALR:
8460         case R_MICROMIPS_JALR:
8461           /* These relocations have empty fields and are purely there to
8462              provide link information.  The symbol value doesn't matter.  */
8463           constrain_symbol_p = FALSE;
8464           break;
8465
8466         case R_MIPS_GPREL16:
8467         case R_MIPS_GPREL32:
8468         case R_MIPS16_GPREL:
8469         case R_MICROMIPS_GPREL16:
8470           /* GP-relative relocations always resolve to a definition in a
8471              regular input file, ignoring the one-definition rule.  This is
8472              important for the GP setup sequence in NewABI code, which
8473              always resolves to a local function even if other relocations
8474              against the symbol wouldn't.  */
8475           constrain_symbol_p = FALSE;
8476           break;
8477
8478         case R_MIPS_32:
8479         case R_MIPS_REL32:
8480         case R_MIPS_64:
8481           /* In VxWorks executables, references to external symbols
8482              must be handled using copy relocs or PLT entries; it is not
8483              possible to convert this relocation into a dynamic one.
8484
8485              For executables that use PLTs and copy-relocs, we have a
8486              choice between converting the relocation into a dynamic
8487              one or using copy relocations or PLT entries.  It is
8488              usually better to do the former, unless the relocation is
8489              against a read-only section.  */
8490           if ((bfd_link_pic (info)
8491                || (h != NULL
8492                    && !htab->is_vxworks
8493                    && strcmp (h->root.root.string, "__gnu_local_gp") != 0
8494                    && !(!info->nocopyreloc
8495                         && !PIC_OBJECT_P (abfd)
8496                         && MIPS_ELF_READONLY_SECTION (sec))))
8497               && (sec->flags & SEC_ALLOC) != 0)
8498             {
8499               can_make_dynamic_p = TRUE;
8500               if (dynobj == NULL)
8501                 elf_hash_table (info)->dynobj = dynobj = abfd;
8502             }
8503           break;
8504
8505         case R_MIPS_26:
8506         case R_MIPS_PC16:
8507         case R_MIPS_PC21_S2:
8508         case R_MIPS_PC26_S2:
8509         case R_MIPS16_26:
8510         case R_MIPS16_PC16_S1:
8511         case R_MICROMIPS_26_S1:
8512         case R_MICROMIPS_PC7_S1:
8513         case R_MICROMIPS_PC10_S1:
8514         case R_MICROMIPS_PC16_S1:
8515         case R_MICROMIPS_PC23_S2:
8516           call_reloc_p = TRUE;
8517           break;
8518         }
8519
8520       if (h)
8521         {
8522           if (constrain_symbol_p)
8523             {
8524               if (!can_make_dynamic_p)
8525                 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1;
8526
8527               if (!call_reloc_p)
8528                 h->pointer_equality_needed = 1;
8529
8530               /* We must not create a stub for a symbol that has
8531                  relocations related to taking the function's address.
8532                  This doesn't apply to VxWorks, where CALL relocs refer
8533                  to a .got.plt entry instead of a normal .got entry.  */
8534               if (!htab->is_vxworks && (!can_make_dynamic_p || !call_reloc_p))
8535                 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8536             }
8537
8538           /* Relocations against the special VxWorks __GOTT_BASE__ and
8539              __GOTT_INDEX__ symbols must be left to the loader.  Allocate
8540              room for them in .rela.dyn.  */
8541           if (is_gott_symbol (info, h))
8542             {
8543               if (sreloc == NULL)
8544                 {
8545                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
8546                   if (sreloc == NULL)
8547                     return FALSE;
8548                 }
8549               mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8550               if (MIPS_ELF_READONLY_SECTION (sec))
8551                 /* We tell the dynamic linker that there are
8552                    relocations against the text segment.  */
8553                 info->flags |= DF_TEXTREL;
8554             }
8555         }
8556       else if (call_lo16_reloc_p (r_type)
8557                || got_lo16_reloc_p (r_type)
8558                || got_disp_reloc_p (r_type)
8559                || (got16_reloc_p (r_type) && htab->is_vxworks))
8560         {
8561           /* We may need a local GOT entry for this relocation.  We
8562              don't count R_MIPS_GOT_PAGE because we can estimate the
8563              maximum number of pages needed by looking at the size of
8564              the segment.  Similar comments apply to R_MIPS*_GOT16 and
8565              R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8566              always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
8567              R_MIPS_CALL_HI16 because these are always followed by an
8568              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
8569           if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8570                                                  rel->r_addend, info, r_type))
8571             return FALSE;
8572         }
8573
8574       if (h != NULL
8575           && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8576                                                   ELF_ST_IS_MIPS16 (h->other)))
8577         ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8578
8579       switch (r_type)
8580         {
8581         case R_MIPS_CALL16:
8582         case R_MIPS16_CALL16:
8583         case R_MICROMIPS_CALL16:
8584           if (h == NULL)
8585             {
8586               _bfd_error_handler
8587                 /* xgettext:c-format */
8588                 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8589                  abfd, (unsigned long) rel->r_offset);
8590               bfd_set_error (bfd_error_bad_value);
8591               return FALSE;
8592             }
8593           /* Fall through.  */
8594
8595         case R_MIPS_CALL_HI16:
8596         case R_MIPS_CALL_LO16:
8597         case R_MICROMIPS_CALL_HI16:
8598         case R_MICROMIPS_CALL_LO16:
8599           if (h != NULL)
8600             {
8601               /* Make sure there is room in the regular GOT to hold the
8602                  function's address.  We may eliminate it in favour of
8603                  a .got.plt entry later; see mips_elf_count_got_symbols.  */
8604               if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
8605                                                       r_type))
8606                 return FALSE;
8607
8608               /* We need a stub, not a plt entry for the undefined
8609                  function.  But we record it as if it needs plt.  See
8610                  _bfd_elf_adjust_dynamic_symbol.  */
8611               h->needs_plt = 1;
8612               h->type = STT_FUNC;
8613             }
8614           break;
8615
8616         case R_MIPS_GOT_PAGE:
8617         case R_MICROMIPS_GOT_PAGE:
8618         case R_MIPS16_GOT16:
8619         case R_MIPS_GOT16:
8620         case R_MIPS_GOT_HI16:
8621         case R_MIPS_GOT_LO16:
8622         case R_MICROMIPS_GOT16:
8623         case R_MICROMIPS_GOT_HI16:
8624         case R_MICROMIPS_GOT_LO16:
8625           if (!h || got_page_reloc_p (r_type))
8626             {
8627               /* This relocation needs (or may need, if h != NULL) a
8628                  page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
8629                  know for sure until we know whether the symbol is
8630                  preemptible.  */
8631               if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8632                 {
8633                   if (!mips_elf_get_section_contents (abfd, sec, &contents))
8634                     return FALSE;
8635                   howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8636                   addend = mips_elf_read_rel_addend (abfd, rel,
8637                                                      howto, contents);
8638                   if (got16_reloc_p (r_type))
8639                     mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8640                                                   contents, &addend);
8641                   else
8642                     addend <<= howto->rightshift;
8643                 }
8644               else
8645                 addend = rel->r_addend;
8646               if (!mips_elf_record_got_page_ref (info, abfd, r_symndx,
8647                                                  h, addend))
8648                 return FALSE;
8649
8650               if (h)
8651                 {
8652                   struct mips_elf_link_hash_entry *hmips =
8653                     (struct mips_elf_link_hash_entry *) h;
8654
8655                   /* This symbol is definitely not overridable.  */
8656                   if (hmips->root.def_regular
8657                       && ! (bfd_link_pic (info) && ! info->symbolic
8658                             && ! hmips->root.forced_local))
8659                     h = NULL;
8660                 }
8661             }
8662           /* If this is a global, overridable symbol, GOT_PAGE will
8663              decay to GOT_DISP, so we'll need a GOT entry for it.  */
8664           /* Fall through.  */
8665
8666         case R_MIPS_GOT_DISP:
8667         case R_MICROMIPS_GOT_DISP:
8668           if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8669                                                        FALSE, r_type))
8670             return FALSE;
8671           break;
8672
8673         case R_MIPS_TLS_GOTTPREL:
8674         case R_MIPS16_TLS_GOTTPREL:
8675         case R_MICROMIPS_TLS_GOTTPREL:
8676           if (bfd_link_pic (info))
8677             info->flags |= DF_STATIC_TLS;
8678           /* Fall through */
8679
8680         case R_MIPS_TLS_LDM:
8681         case R_MIPS16_TLS_LDM:
8682         case R_MICROMIPS_TLS_LDM:
8683           if (tls_ldm_reloc_p (r_type))
8684             {
8685               r_symndx = STN_UNDEF;
8686               h = NULL;
8687             }
8688           /* Fall through */
8689
8690         case R_MIPS_TLS_GD:
8691         case R_MIPS16_TLS_GD:
8692         case R_MICROMIPS_TLS_GD:
8693           /* This symbol requires a global offset table entry, or two
8694              for TLS GD relocations.  */
8695           if (h != NULL)
8696             {
8697               if (!mips_elf_record_global_got_symbol (h, abfd, info,
8698                                                       FALSE, r_type))
8699                 return FALSE;
8700             }
8701           else
8702             {
8703               if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8704                                                      rel->r_addend,
8705                                                      info, r_type))
8706                 return FALSE;
8707             }
8708           break;
8709
8710         case R_MIPS_32:
8711         case R_MIPS_REL32:
8712         case R_MIPS_64:
8713           /* In VxWorks executables, references to external symbols
8714              are handled using copy relocs or PLT stubs, so there's
8715              no need to add a .rela.dyn entry for this relocation.  */
8716           if (can_make_dynamic_p)
8717             {
8718               if (sreloc == NULL)
8719                 {
8720                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
8721                   if (sreloc == NULL)
8722                     return FALSE;
8723                 }
8724               if (bfd_link_pic (info) && h == NULL)
8725                 {
8726                   /* When creating a shared object, we must copy these
8727                      reloc types into the output file as R_MIPS_REL32
8728                      relocs.  Make room for this reloc in .rel(a).dyn.  */
8729                   mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8730                   if (MIPS_ELF_READONLY_SECTION (sec))
8731                     /* We tell the dynamic linker that there are
8732                        relocations against the text segment.  */
8733                     info->flags |= DF_TEXTREL;
8734                 }
8735               else
8736                 {
8737                   struct mips_elf_link_hash_entry *hmips;
8738
8739                   /* For a shared object, we must copy this relocation
8740                      unless the symbol turns out to be undefined and
8741                      weak with non-default visibility, in which case
8742                      it will be left as zero.
8743
8744                      We could elide R_MIPS_REL32 for locally binding symbols
8745                      in shared libraries, but do not yet do so.
8746
8747                      For an executable, we only need to copy this
8748                      reloc if the symbol is defined in a dynamic
8749                      object.  */
8750                   hmips = (struct mips_elf_link_hash_entry *) h;
8751                   ++hmips->possibly_dynamic_relocs;
8752                   if (MIPS_ELF_READONLY_SECTION (sec))
8753                     /* We need it to tell the dynamic linker if there
8754                        are relocations against the text segment.  */
8755                     hmips->readonly_reloc = TRUE;
8756                 }
8757             }
8758
8759           if (SGI_COMPAT (abfd))
8760             mips_elf_hash_table (info)->compact_rel_size +=
8761               sizeof (Elf32_External_crinfo);
8762           break;
8763
8764         case R_MIPS_26:
8765         case R_MIPS_GPREL16:
8766         case R_MIPS_LITERAL:
8767         case R_MIPS_GPREL32:
8768         case R_MICROMIPS_26_S1:
8769         case R_MICROMIPS_GPREL16:
8770         case R_MICROMIPS_LITERAL:
8771         case R_MICROMIPS_GPREL7_S2:
8772           if (SGI_COMPAT (abfd))
8773             mips_elf_hash_table (info)->compact_rel_size +=
8774               sizeof (Elf32_External_crinfo);
8775           break;
8776
8777           /* This relocation describes the C++ object vtable hierarchy.
8778              Reconstruct it for later use during GC.  */
8779         case R_MIPS_GNU_VTINHERIT:
8780           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8781             return FALSE;
8782           break;
8783
8784           /* This relocation describes which C++ vtable entries are actually
8785              used.  Record for later use during GC.  */
8786         case R_MIPS_GNU_VTENTRY:
8787           BFD_ASSERT (h != NULL);
8788           if (h != NULL
8789               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8790             return FALSE;
8791           break;
8792
8793         default:
8794           break;
8795         }
8796
8797       /* Record the need for a PLT entry.  At this point we don't know
8798          yet if we are going to create a PLT in the first place, but
8799          we only record whether the relocation requires a standard MIPS
8800          or a compressed code entry anyway.  If we don't make a PLT after
8801          all, then we'll just ignore these arrangements.  Likewise if
8802          a PLT entry is not created because the symbol is satisfied
8803          locally.  */
8804       if (h != NULL
8805           && (branch_reloc_p (r_type)
8806               || mips16_branch_reloc_p (r_type)
8807               || micromips_branch_reloc_p (r_type))
8808           && !SYMBOL_CALLS_LOCAL (info, h))
8809         {
8810           if (h->plt.plist == NULL)
8811             h->plt.plist = mips_elf_make_plt_record (abfd);
8812           if (h->plt.plist == NULL)
8813             return FALSE;
8814
8815           if (branch_reloc_p (r_type))
8816             h->plt.plist->need_mips = TRUE;
8817           else
8818             h->plt.plist->need_comp = TRUE;
8819         }
8820
8821       /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8822          if there is one.  We only need to handle global symbols here;
8823          we decide whether to keep or delete stubs for local symbols
8824          when processing the stub's relocations.  */
8825       if (h != NULL
8826           && !mips16_call_reloc_p (r_type)
8827           && !section_allows_mips16_refs_p (sec))
8828         {
8829           struct mips_elf_link_hash_entry *mh;
8830
8831           mh = (struct mips_elf_link_hash_entry *) h;
8832           mh->need_fn_stub = TRUE;
8833         }
8834
8835       /* Refuse some position-dependent relocations when creating a
8836          shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
8837          not PIC, but we can create dynamic relocations and the result
8838          will be fine.  Also do not refuse R_MIPS_LO16, which can be
8839          combined with R_MIPS_GOT16.  */
8840       if (bfd_link_pic (info))
8841         {
8842           switch (r_type)
8843             {
8844             case R_MIPS16_HI16:
8845             case R_MIPS_HI16:
8846             case R_MIPS_HIGHER:
8847             case R_MIPS_HIGHEST:
8848             case R_MICROMIPS_HI16:
8849             case R_MICROMIPS_HIGHER:
8850             case R_MICROMIPS_HIGHEST:
8851               /* Don't refuse a high part relocation if it's against
8852                  no symbol (e.g. part of a compound relocation).  */
8853               if (r_symndx == STN_UNDEF)
8854                 break;
8855
8856               /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8857                  and has a special meaning.  */
8858               if (!NEWABI_P (abfd) && h != NULL
8859                   && strcmp (h->root.root.string, "_gp_disp") == 0)
8860                 break;
8861
8862               /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks.  */
8863               if (is_gott_symbol (info, h))
8864                 break;
8865
8866               /* FALLTHROUGH */
8867
8868             case R_MIPS16_26:
8869             case R_MIPS_26:
8870             case R_MICROMIPS_26_S1:
8871               howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8872               _bfd_error_handler
8873                 /* xgettext:c-format */
8874                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8875                  abfd, howto->name,
8876                  (h) ? h->root.root.string : "a local symbol");
8877               bfd_set_error (bfd_error_bad_value);
8878               return FALSE;
8879             default:
8880               break;
8881             }
8882         }
8883     }
8884
8885   return TRUE;
8886 }
8887 \f
8888 bfd_boolean
8889 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8890                          struct bfd_link_info *link_info,
8891                          bfd_boolean *again)
8892 {
8893   Elf_Internal_Rela *internal_relocs;
8894   Elf_Internal_Rela *irel, *irelend;
8895   Elf_Internal_Shdr *symtab_hdr;
8896   bfd_byte *contents = NULL;
8897   size_t extsymoff;
8898   bfd_boolean changed_contents = FALSE;
8899   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8900   Elf_Internal_Sym *isymbuf = NULL;
8901
8902   /* We are not currently changing any sizes, so only one pass.  */
8903   *again = FALSE;
8904
8905   if (bfd_link_relocatable (link_info))
8906     return TRUE;
8907
8908   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8909                                                link_info->keep_memory);
8910   if (internal_relocs == NULL)
8911     return TRUE;
8912
8913   irelend = internal_relocs + sec->reloc_count
8914     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8915   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8916   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8917
8918   for (irel = internal_relocs; irel < irelend; irel++)
8919     {
8920       bfd_vma symval;
8921       bfd_signed_vma sym_offset;
8922       unsigned int r_type;
8923       unsigned long r_symndx;
8924       asection *sym_sec;
8925       unsigned long instruction;
8926
8927       /* Turn jalr into bgezal, and jr into beq, if they're marked
8928          with a JALR relocation, that indicate where they jump to.
8929          This saves some pipeline bubbles.  */
8930       r_type = ELF_R_TYPE (abfd, irel->r_info);
8931       if (r_type != R_MIPS_JALR)
8932         continue;
8933
8934       r_symndx = ELF_R_SYM (abfd, irel->r_info);
8935       /* Compute the address of the jump target.  */
8936       if (r_symndx >= extsymoff)
8937         {
8938           struct mips_elf_link_hash_entry *h
8939             = ((struct mips_elf_link_hash_entry *)
8940                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8941
8942           while (h->root.root.type == bfd_link_hash_indirect
8943                  || h->root.root.type == bfd_link_hash_warning)
8944             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8945
8946           /* If a symbol is undefined, or if it may be overridden,
8947              skip it.  */
8948           if (! ((h->root.root.type == bfd_link_hash_defined
8949                   || h->root.root.type == bfd_link_hash_defweak)
8950                  && h->root.root.u.def.section)
8951               || (bfd_link_pic (link_info) && ! link_info->symbolic
8952                   && !h->root.forced_local))
8953             continue;
8954
8955           sym_sec = h->root.root.u.def.section;
8956           if (sym_sec->output_section)
8957             symval = (h->root.root.u.def.value
8958                       + sym_sec->output_section->vma
8959                       + sym_sec->output_offset);
8960           else
8961             symval = h->root.root.u.def.value;
8962         }
8963       else
8964         {
8965           Elf_Internal_Sym *isym;
8966
8967           /* Read this BFD's symbols if we haven't done so already.  */
8968           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8969             {
8970               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8971               if (isymbuf == NULL)
8972                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8973                                                 symtab_hdr->sh_info, 0,
8974                                                 NULL, NULL, NULL);
8975               if (isymbuf == NULL)
8976                 goto relax_return;
8977             }
8978
8979           isym = isymbuf + r_symndx;
8980           if (isym->st_shndx == SHN_UNDEF)
8981             continue;
8982           else if (isym->st_shndx == SHN_ABS)
8983             sym_sec = bfd_abs_section_ptr;
8984           else if (isym->st_shndx == SHN_COMMON)
8985             sym_sec = bfd_com_section_ptr;
8986           else
8987             sym_sec
8988               = bfd_section_from_elf_index (abfd, isym->st_shndx);
8989           symval = isym->st_value
8990             + sym_sec->output_section->vma
8991             + sym_sec->output_offset;
8992         }
8993
8994       /* Compute branch offset, from delay slot of the jump to the
8995          branch target.  */
8996       sym_offset = (symval + irel->r_addend)
8997         - (sec_start + irel->r_offset + 4);
8998
8999       /* Branch offset must be properly aligned.  */
9000       if ((sym_offset & 3) != 0)
9001         continue;
9002
9003       sym_offset >>= 2;
9004
9005       /* Check that it's in range.  */
9006       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
9007         continue;
9008
9009       /* Get the section contents if we haven't done so already.  */
9010       if (!mips_elf_get_section_contents (abfd, sec, &contents))
9011         goto relax_return;
9012
9013       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
9014
9015       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
9016       if ((instruction & 0xfc1fffff) == 0x0000f809)
9017         instruction = 0x04110000;
9018       /* If it was jr <reg>, turn it into b <target>.  */
9019       else if ((instruction & 0xfc1fffff) == 0x00000008)
9020         instruction = 0x10000000;
9021       else
9022         continue;
9023
9024       instruction |= (sym_offset & 0xffff);
9025       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
9026       changed_contents = TRUE;
9027     }
9028
9029   if (contents != NULL
9030       && elf_section_data (sec)->this_hdr.contents != contents)
9031     {
9032       if (!changed_contents && !link_info->keep_memory)
9033         free (contents);
9034       else
9035         {
9036           /* Cache the section contents for elf_link_input_bfd.  */
9037           elf_section_data (sec)->this_hdr.contents = contents;
9038         }
9039     }
9040   return TRUE;
9041
9042  relax_return:
9043   if (contents != NULL
9044       && elf_section_data (sec)->this_hdr.contents != contents)
9045     free (contents);
9046   return FALSE;
9047 }
9048 \f
9049 /* Allocate space for global sym dynamic relocs.  */
9050
9051 static bfd_boolean
9052 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9053 {
9054   struct bfd_link_info *info = inf;
9055   bfd *dynobj;
9056   struct mips_elf_link_hash_entry *hmips;
9057   struct mips_elf_link_hash_table *htab;
9058
9059   htab = mips_elf_hash_table (info);
9060   BFD_ASSERT (htab != NULL);
9061
9062   dynobj = elf_hash_table (info)->dynobj;
9063   hmips = (struct mips_elf_link_hash_entry *) h;
9064
9065   /* VxWorks executables are handled elsewhere; we only need to
9066      allocate relocations in shared objects.  */
9067   if (htab->is_vxworks && !bfd_link_pic (info))
9068     return TRUE;
9069
9070   /* Ignore indirect symbols.  All relocations against such symbols
9071      will be redirected to the target symbol.  */
9072   if (h->root.type == bfd_link_hash_indirect)
9073     return TRUE;
9074
9075   /* If this symbol is defined in a dynamic object, or we are creating
9076      a shared library, we will need to copy any R_MIPS_32 or
9077      R_MIPS_REL32 relocs against it into the output file.  */
9078   if (! bfd_link_relocatable (info)
9079       && hmips->possibly_dynamic_relocs != 0
9080       && (h->root.type == bfd_link_hash_defweak
9081           || (!h->def_regular && !ELF_COMMON_DEF_P (h))
9082           || bfd_link_pic (info)))
9083     {
9084       bfd_boolean do_copy = TRUE;
9085
9086       if (h->root.type == bfd_link_hash_undefweak)
9087         {
9088           /* Do not copy relocations for undefined weak symbols with
9089              non-default visibility.  */
9090           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9091             do_copy = FALSE;
9092
9093           /* Make sure undefined weak symbols are output as a dynamic
9094              symbol in PIEs.  */
9095           else if (h->dynindx == -1 && !h->forced_local)
9096             {
9097               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9098                 return FALSE;
9099             }
9100         }
9101
9102       if (do_copy)
9103         {
9104           /* Even though we don't directly need a GOT entry for this symbol,
9105              the SVR4 psABI requires it to have a dynamic symbol table
9106              index greater that DT_MIPS_GOTSYM if there are dynamic
9107              relocations against it.
9108
9109              VxWorks does not enforce the same mapping between the GOT
9110              and the symbol table, so the same requirement does not
9111              apply there.  */
9112           if (!htab->is_vxworks)
9113             {
9114               if (hmips->global_got_area > GGA_RELOC_ONLY)
9115                 hmips->global_got_area = GGA_RELOC_ONLY;
9116               hmips->got_only_for_calls = FALSE;
9117             }
9118
9119           mips_elf_allocate_dynamic_relocations
9120             (dynobj, info, hmips->possibly_dynamic_relocs);
9121           if (hmips->readonly_reloc)
9122             /* We tell the dynamic linker that there are relocations
9123                against the text segment.  */
9124             info->flags |= DF_TEXTREL;
9125         }
9126     }
9127
9128   return TRUE;
9129 }
9130
9131 /* Adjust a symbol defined by a dynamic object and referenced by a
9132    regular object.  The current definition is in some section of the
9133    dynamic object, but we're not including those sections.  We have to
9134    change the definition to something the rest of the link can
9135    understand.  */
9136
9137 bfd_boolean
9138 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
9139                                      struct elf_link_hash_entry *h)
9140 {
9141   bfd *dynobj;
9142   struct mips_elf_link_hash_entry *hmips;
9143   struct mips_elf_link_hash_table *htab;
9144
9145   htab = mips_elf_hash_table (info);
9146   BFD_ASSERT (htab != NULL);
9147
9148   dynobj = elf_hash_table (info)->dynobj;
9149   hmips = (struct mips_elf_link_hash_entry *) h;
9150
9151   /* Make sure we know what is going on here.  */
9152   BFD_ASSERT (dynobj != NULL
9153               && (h->needs_plt
9154                   || h->u.weakdef != NULL
9155                   || (h->def_dynamic
9156                       && h->ref_regular
9157                       && !h->def_regular)));
9158
9159   hmips = (struct mips_elf_link_hash_entry *) h;
9160
9161   /* If there are call relocations against an externally-defined symbol,
9162      see whether we can create a MIPS lazy-binding stub for it.  We can
9163      only do this if all references to the function are through call
9164      relocations, and in that case, the traditional lazy-binding stubs
9165      are much more efficient than PLT entries.
9166
9167      Traditional stubs are only available on SVR4 psABI-based systems;
9168      VxWorks always uses PLTs instead.  */
9169   if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
9170     {
9171       if (! elf_hash_table (info)->dynamic_sections_created)
9172         return TRUE;
9173
9174       /* If this symbol is not defined in a regular file, then set
9175          the symbol to the stub location.  This is required to make
9176          function pointers compare as equal between the normal
9177          executable and the shared library.  */
9178       if (!h->def_regular)
9179         {
9180           hmips->needs_lazy_stub = TRUE;
9181           htab->lazy_stub_count++;
9182           return TRUE;
9183         }
9184     }
9185   /* As above, VxWorks requires PLT entries for externally-defined
9186      functions that are only accessed through call relocations.
9187
9188      Both VxWorks and non-VxWorks targets also need PLT entries if there
9189      are static-only relocations against an externally-defined function.
9190      This can technically occur for shared libraries if there are
9191      branches to the symbol, although it is unlikely that this will be
9192      used in practice due to the short ranges involved.  It can occur
9193      for any relative or absolute relocation in executables; in that
9194      case, the PLT entry becomes the function's canonical address.  */
9195   else if (((h->needs_plt && !hmips->no_fn_stub)
9196             || (h->type == STT_FUNC && hmips->has_static_relocs))
9197            && htab->use_plts_and_copy_relocs
9198            && !SYMBOL_CALLS_LOCAL (info, h)
9199            && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9200                 && h->root.type == bfd_link_hash_undefweak))
9201     {
9202       bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9203       bfd_boolean newabi_p = NEWABI_P (info->output_bfd);
9204
9205       /* If this is the first symbol to need a PLT entry, then make some
9206          basic setup.  Also work out PLT entry sizes.  We'll need them
9207          for PLT offset calculations.  */
9208       if (htab->plt_mips_offset + htab->plt_comp_offset == 0)
9209         {
9210           BFD_ASSERT (htab->root.sgotplt->size == 0);
9211           BFD_ASSERT (htab->plt_got_index == 0);
9212
9213           /* If we're using the PLT additions to the psABI, each PLT
9214              entry is 16 bytes and the PLT0 entry is 32 bytes.
9215              Encourage better cache usage by aligning.  We do this
9216              lazily to avoid pessimizing traditional objects.  */
9217           if (!htab->is_vxworks
9218               && !bfd_set_section_alignment (dynobj, htab->root.splt, 5))
9219             return FALSE;
9220
9221           /* Make sure that .got.plt is word-aligned.  We do this lazily
9222              for the same reason as above.  */
9223           if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt,
9224                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
9225             return FALSE;
9226
9227           /* On non-VxWorks targets, the first two entries in .got.plt
9228              are reserved.  */
9229           if (!htab->is_vxworks)
9230             htab->plt_got_index
9231               += (get_elf_backend_data (dynobj)->got_header_size
9232                   / MIPS_ELF_GOT_SIZE (dynobj));
9233
9234           /* On VxWorks, also allocate room for the header's
9235              .rela.plt.unloaded entries.  */
9236           if (htab->is_vxworks && !bfd_link_pic (info))
9237             htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
9238
9239           /* Now work out the sizes of individual PLT entries.  */
9240           if (htab->is_vxworks && bfd_link_pic (info))
9241             htab->plt_mips_entry_size
9242               = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
9243           else if (htab->is_vxworks)
9244             htab->plt_mips_entry_size
9245               = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
9246           else if (newabi_p)
9247             htab->plt_mips_entry_size
9248               = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9249           else if (!micromips_p)
9250             {
9251               htab->plt_mips_entry_size
9252                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9253               htab->plt_comp_entry_size
9254                 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
9255             }
9256           else if (htab->insn32)
9257             {
9258               htab->plt_mips_entry_size
9259                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9260               htab->plt_comp_entry_size
9261                 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
9262             }
9263           else
9264             {
9265               htab->plt_mips_entry_size
9266                 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9267               htab->plt_comp_entry_size
9268                 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
9269             }
9270         }
9271
9272       if (h->plt.plist == NULL)
9273         h->plt.plist = mips_elf_make_plt_record (dynobj);
9274       if (h->plt.plist == NULL)
9275         return FALSE;
9276
9277       /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9278          n32 or n64, so always use a standard entry there.
9279
9280          If the symbol has a MIPS16 call stub and gets a PLT entry, then
9281          all MIPS16 calls will go via that stub, and there is no benefit
9282          to having a MIPS16 entry.  And in the case of call_stub a
9283          standard entry actually has to be used as the stub ends with a J
9284          instruction.  */
9285       if (newabi_p
9286           || htab->is_vxworks
9287           || hmips->call_stub
9288           || hmips->call_fp_stub)
9289         {
9290           h->plt.plist->need_mips = TRUE;
9291           h->plt.plist->need_comp = FALSE;
9292         }
9293
9294       /* Otherwise, if there are no direct calls to the function, we
9295          have a free choice of whether to use standard or compressed
9296          entries.  Prefer microMIPS entries if the object is known to
9297          contain microMIPS code, so that it becomes possible to create
9298          pure microMIPS binaries.  Prefer standard entries otherwise,
9299          because MIPS16 ones are no smaller and are usually slower.  */
9300       if (!h->plt.plist->need_mips && !h->plt.plist->need_comp)
9301         {
9302           if (micromips_p)
9303             h->plt.plist->need_comp = TRUE;
9304           else
9305             h->plt.plist->need_mips = TRUE;
9306         }
9307
9308       if (h->plt.plist->need_mips)
9309         {
9310           h->plt.plist->mips_offset = htab->plt_mips_offset;
9311           htab->plt_mips_offset += htab->plt_mips_entry_size;
9312         }
9313       if (h->plt.plist->need_comp)
9314         {
9315           h->plt.plist->comp_offset = htab->plt_comp_offset;
9316           htab->plt_comp_offset += htab->plt_comp_entry_size;
9317         }
9318
9319       /* Reserve the corresponding .got.plt entry now too.  */
9320       h->plt.plist->gotplt_index = htab->plt_got_index++;
9321
9322       /* If the output file has no definition of the symbol, set the
9323          symbol's value to the address of the stub.  */
9324       if (!bfd_link_pic (info) && !h->def_regular)
9325         hmips->use_plt_entry = TRUE;
9326
9327       /* Make room for the R_MIPS_JUMP_SLOT relocation.  */
9328       htab->root.srelplt->size += (htab->is_vxworks
9329                                    ? MIPS_ELF_RELA_SIZE (dynobj)
9330                                    : MIPS_ELF_REL_SIZE (dynobj));
9331
9332       /* Make room for the .rela.plt.unloaded relocations.  */
9333       if (htab->is_vxworks && !bfd_link_pic (info))
9334         htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
9335
9336       /* All relocations against this symbol that could have been made
9337          dynamic will now refer to the PLT entry instead.  */
9338       hmips->possibly_dynamic_relocs = 0;
9339
9340       return TRUE;
9341     }
9342
9343   /* If this is a weak symbol, and there is a real definition, the
9344      processor independent code will have arranged for us to see the
9345      real definition first, and we can just use the same value.  */
9346   if (h->u.weakdef != NULL)
9347     {
9348       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
9349                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
9350       h->root.u.def.section = h->u.weakdef->root.u.def.section;
9351       h->root.u.def.value = h->u.weakdef->root.u.def.value;
9352       return TRUE;
9353     }
9354
9355   /* Otherwise, there is nothing further to do for symbols defined
9356      in regular objects.  */
9357   if (h->def_regular)
9358     return TRUE;
9359
9360   /* There's also nothing more to do if we'll convert all relocations
9361      against this symbol into dynamic relocations.  */
9362   if (!hmips->has_static_relocs)
9363     return TRUE;
9364
9365   /* We're now relying on copy relocations.  Complain if we have
9366      some that we can't convert.  */
9367   if (!htab->use_plts_and_copy_relocs || bfd_link_pic (info))
9368     {
9369       _bfd_error_handler (_("non-dynamic relocations refer to "
9370                             "dynamic symbol %s"),
9371                           h->root.root.string);
9372       bfd_set_error (bfd_error_bad_value);
9373       return FALSE;
9374     }
9375
9376   /* We must allocate the symbol in our .dynbss section, which will
9377      become part of the .bss section of the executable.  There will be
9378      an entry for this symbol in the .dynsym section.  The dynamic
9379      object will contain position independent code, so all references
9380      from the dynamic object to this symbol will go through the global
9381      offset table.  The dynamic linker will use the .dynsym entry to
9382      determine the address it must put in the global offset table, so
9383      both the dynamic object and the regular object will refer to the
9384      same memory location for the variable.  */
9385
9386   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
9387     {
9388       if (htab->is_vxworks)
9389         htab->srelbss->size += sizeof (Elf32_External_Rela);
9390       else
9391         mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
9392       h->needs_copy = 1;
9393     }
9394
9395   /* All relocations against this symbol that could have been made
9396      dynamic will now refer to the local copy instead.  */
9397   hmips->possibly_dynamic_relocs = 0;
9398
9399   return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdynbss);
9400 }
9401 \f
9402 /* This function is called after all the input files have been read,
9403    and the input sections have been assigned to output sections.  We
9404    check for any mips16 stub sections that we can discard.  */
9405
9406 bfd_boolean
9407 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
9408                                     struct bfd_link_info *info)
9409 {
9410   asection *sect;
9411   struct mips_elf_link_hash_table *htab;
9412   struct mips_htab_traverse_info hti;
9413
9414   htab = mips_elf_hash_table (info);
9415   BFD_ASSERT (htab != NULL);
9416
9417   /* The .reginfo section has a fixed size.  */
9418   sect = bfd_get_section_by_name (output_bfd, ".reginfo");
9419   if (sect != NULL)
9420     bfd_set_section_size (output_bfd, sect, sizeof (Elf32_External_RegInfo));
9421
9422   /* The .MIPS.abiflags section has a fixed size.  */
9423   sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags");
9424   if (sect != NULL)
9425     bfd_set_section_size (output_bfd, sect, sizeof (Elf_External_ABIFlags_v0));
9426
9427   hti.info = info;
9428   hti.output_bfd = output_bfd;
9429   hti.error = FALSE;
9430   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9431                                mips_elf_check_symbols, &hti);
9432   if (hti.error)
9433     return FALSE;
9434
9435   return TRUE;
9436 }
9437
9438 /* If the link uses a GOT, lay it out and work out its size.  */
9439
9440 static bfd_boolean
9441 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
9442 {
9443   bfd *dynobj;
9444   asection *s;
9445   struct mips_got_info *g;
9446   bfd_size_type loadable_size = 0;
9447   bfd_size_type page_gotno;
9448   bfd *ibfd;
9449   struct mips_elf_traverse_got_arg tga;
9450   struct mips_elf_link_hash_table *htab;
9451
9452   htab = mips_elf_hash_table (info);
9453   BFD_ASSERT (htab != NULL);
9454
9455   s = htab->root.sgot;
9456   if (s == NULL)
9457     return TRUE;
9458
9459   dynobj = elf_hash_table (info)->dynobj;
9460   g = htab->got_info;
9461
9462   /* Allocate room for the reserved entries.  VxWorks always reserves
9463      3 entries; other objects only reserve 2 entries.  */
9464   BFD_ASSERT (g->assigned_low_gotno == 0);
9465   if (htab->is_vxworks)
9466     htab->reserved_gotno = 3;
9467   else
9468     htab->reserved_gotno = 2;
9469   g->local_gotno += htab->reserved_gotno;
9470   g->assigned_low_gotno = htab->reserved_gotno;
9471
9472   /* Decide which symbols need to go in the global part of the GOT and
9473      count the number of reloc-only GOT symbols.  */
9474   mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
9475
9476   if (!mips_elf_resolve_final_got_entries (info, g))
9477     return FALSE;
9478
9479   /* Calculate the total loadable size of the output.  That
9480      will give us the maximum number of GOT_PAGE entries
9481      required.  */
9482   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9483     {
9484       asection *subsection;
9485
9486       for (subsection = ibfd->sections;
9487            subsection;
9488            subsection = subsection->next)
9489         {
9490           if ((subsection->flags & SEC_ALLOC) == 0)
9491             continue;
9492           loadable_size += ((subsection->size + 0xf)
9493                             &~ (bfd_size_type) 0xf);
9494         }
9495     }
9496
9497   if (htab->is_vxworks)
9498     /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9499        relocations against local symbols evaluate to "G", and the EABI does
9500        not include R_MIPS_GOT_PAGE.  */
9501     page_gotno = 0;
9502   else
9503     /* Assume there are two loadable segments consisting of contiguous
9504        sections.  Is 5 enough?  */
9505     page_gotno = (loadable_size >> 16) + 5;
9506
9507   /* Choose the smaller of the two page estimates; both are intended to be
9508      conservative.  */
9509   if (page_gotno > g->page_gotno)
9510     page_gotno = g->page_gotno;
9511
9512   g->local_gotno += page_gotno;
9513   g->assigned_high_gotno = g->local_gotno - 1;
9514
9515   s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9516   s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9517   s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9518
9519   /* VxWorks does not support multiple GOTs.  It initializes $gp to
9520      __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9521      dynamic loader.  */
9522   if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
9523     {
9524       if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
9525         return FALSE;
9526     }
9527   else
9528     {
9529       /* Record that all bfds use G.  This also has the effect of freeing
9530          the per-bfd GOTs, which we no longer need.  */
9531       for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9532         if (mips_elf_bfd_got (ibfd, FALSE))
9533           mips_elf_replace_bfd_got (ibfd, g);
9534       mips_elf_replace_bfd_got (output_bfd, g);
9535
9536       /* Set up TLS entries.  */
9537       g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
9538       tga.info = info;
9539       tga.g = g;
9540       tga.value = MIPS_ELF_GOT_SIZE (output_bfd);
9541       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
9542       if (!tga.g)
9543         return FALSE;
9544       BFD_ASSERT (g->tls_assigned_gotno
9545                   == g->global_gotno + g->local_gotno + g->tls_gotno);
9546
9547       /* Each VxWorks GOT entry needs an explicit relocation.  */
9548       if (htab->is_vxworks && bfd_link_pic (info))
9549         g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno;
9550
9551       /* Allocate room for the TLS relocations.  */
9552       if (g->relocs)
9553         mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
9554     }
9555
9556   return TRUE;
9557 }
9558
9559 /* Estimate the size of the .MIPS.stubs section.  */
9560
9561 static void
9562 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
9563 {
9564   struct mips_elf_link_hash_table *htab;
9565   bfd_size_type dynsymcount;
9566
9567   htab = mips_elf_hash_table (info);
9568   BFD_ASSERT (htab != NULL);
9569
9570   if (htab->lazy_stub_count == 0)
9571     return;
9572
9573   /* IRIX rld assumes that a function stub isn't at the end of the .text
9574      section, so add a dummy entry to the end.  */
9575   htab->lazy_stub_count++;
9576
9577   /* Get a worst-case estimate of the number of dynamic symbols needed.
9578      At this point, dynsymcount does not account for section symbols
9579      and count_section_dynsyms may overestimate the number that will
9580      be needed.  */
9581   dynsymcount = (elf_hash_table (info)->dynsymcount
9582                  + count_section_dynsyms (output_bfd, info));
9583
9584   /* Determine the size of one stub entry.  There's no disadvantage
9585      from using microMIPS code here, so for the sake of pure-microMIPS
9586      binaries we prefer it whenever there's any microMIPS code in
9587      output produced at all.  This has a benefit of stubs being
9588      shorter by 4 bytes each too, unless in the insn32 mode.  */
9589   if (!MICROMIPS_P (output_bfd))
9590     htab->function_stub_size = (dynsymcount > 0x10000
9591                                 ? MIPS_FUNCTION_STUB_BIG_SIZE
9592                                 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
9593   else if (htab->insn32)
9594     htab->function_stub_size = (dynsymcount > 0x10000
9595                                 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9596                                 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE);
9597   else
9598     htab->function_stub_size = (dynsymcount > 0x10000
9599                                 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9600                                 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE);
9601
9602   htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
9603 }
9604
9605 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9606    mips_htab_traverse_info.  If H needs a traditional MIPS lazy-binding
9607    stub, allocate an entry in the stubs section.  */
9608
9609 static bfd_boolean
9610 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data)
9611 {
9612   struct mips_htab_traverse_info *hti = data;
9613   struct mips_elf_link_hash_table *htab;
9614   struct bfd_link_info *info;
9615   bfd *output_bfd;
9616
9617   info = hti->info;
9618   output_bfd = hti->output_bfd;
9619   htab = mips_elf_hash_table (info);
9620   BFD_ASSERT (htab != NULL);
9621
9622   if (h->needs_lazy_stub)
9623     {
9624       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9625       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9626       bfd_vma isa_bit = micromips_p;
9627
9628       BFD_ASSERT (htab->root.dynobj != NULL);
9629       if (h->root.plt.plist == NULL)
9630         h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner);
9631       if (h->root.plt.plist == NULL)
9632         {
9633           hti->error = TRUE;
9634           return FALSE;
9635         }
9636       h->root.root.u.def.section = htab->sstubs;
9637       h->root.root.u.def.value = htab->sstubs->size + isa_bit;
9638       h->root.plt.plist->stub_offset = htab->sstubs->size;
9639       h->root.other = other;
9640       htab->sstubs->size += htab->function_stub_size;
9641     }
9642   return TRUE;
9643 }
9644
9645 /* Allocate offsets in the stubs section to each symbol that needs one.
9646    Set the final size of the .MIPS.stub section.  */
9647
9648 static bfd_boolean
9649 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
9650 {
9651   bfd *output_bfd = info->output_bfd;
9652   bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9653   unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9654   bfd_vma isa_bit = micromips_p;
9655   struct mips_elf_link_hash_table *htab;
9656   struct mips_htab_traverse_info hti;
9657   struct elf_link_hash_entry *h;
9658   bfd *dynobj;
9659
9660   htab = mips_elf_hash_table (info);
9661   BFD_ASSERT (htab != NULL);
9662
9663   if (htab->lazy_stub_count == 0)
9664     return TRUE;
9665
9666   htab->sstubs->size = 0;
9667   hti.info = info;
9668   hti.output_bfd = output_bfd;
9669   hti.error = FALSE;
9670   mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti);
9671   if (hti.error)
9672     return FALSE;
9673   htab->sstubs->size += htab->function_stub_size;
9674   BFD_ASSERT (htab->sstubs->size
9675               == htab->lazy_stub_count * htab->function_stub_size);
9676
9677   dynobj = elf_hash_table (info)->dynobj;
9678   BFD_ASSERT (dynobj != NULL);
9679   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_");
9680   if (h == NULL)
9681     return FALSE;
9682   h->root.u.def.value = isa_bit;
9683   h->other = other;
9684   h->type = STT_FUNC;
9685
9686   return TRUE;
9687 }
9688
9689 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9690    bfd_link_info.  If H uses the address of a PLT entry as the value
9691    of the symbol, then set the entry in the symbol table now.  Prefer
9692    a standard MIPS PLT entry.  */
9693
9694 static bfd_boolean
9695 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data)
9696 {
9697   struct bfd_link_info *info = data;
9698   bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9699   struct mips_elf_link_hash_table *htab;
9700   unsigned int other;
9701   bfd_vma isa_bit;
9702   bfd_vma val;
9703
9704   htab = mips_elf_hash_table (info);
9705   BFD_ASSERT (htab != NULL);
9706
9707   if (h->use_plt_entry)
9708     {
9709       BFD_ASSERT (h->root.plt.plist != NULL);
9710       BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE
9711                   || h->root.plt.plist->comp_offset != MINUS_ONE);
9712
9713       val = htab->plt_header_size;
9714       if (h->root.plt.plist->mips_offset != MINUS_ONE)
9715         {
9716           isa_bit = 0;
9717           val += h->root.plt.plist->mips_offset;
9718           other = 0;
9719         }
9720       else
9721         {
9722           isa_bit = 1;
9723           val += htab->plt_mips_offset + h->root.plt.plist->comp_offset;
9724           other = micromips_p ? STO_MICROMIPS : STO_MIPS16;
9725         }
9726       val += isa_bit;
9727       /* For VxWorks, point at the PLT load stub rather than the lazy
9728          resolution stub; this stub will become the canonical function
9729          address.  */
9730       if (htab->is_vxworks)
9731         val += 8;
9732
9733       h->root.root.u.def.section = htab->root.splt;
9734       h->root.root.u.def.value = val;
9735       h->root.other = other;
9736     }
9737
9738   return TRUE;
9739 }
9740
9741 /* Set the sizes of the dynamic sections.  */
9742
9743 bfd_boolean
9744 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9745                                      struct bfd_link_info *info)
9746 {
9747   bfd *dynobj;
9748   asection *s, *sreldyn;
9749   bfd_boolean reltext;
9750   struct mips_elf_link_hash_table *htab;
9751
9752   htab = mips_elf_hash_table (info);
9753   BFD_ASSERT (htab != NULL);
9754   dynobj = elf_hash_table (info)->dynobj;
9755   BFD_ASSERT (dynobj != NULL);
9756
9757   if (elf_hash_table (info)->dynamic_sections_created)
9758     {
9759       /* Set the contents of the .interp section to the interpreter.  */
9760       if (bfd_link_executable (info) && !info->nointerp)
9761         {
9762           s = bfd_get_linker_section (dynobj, ".interp");
9763           BFD_ASSERT (s != NULL);
9764           s->size
9765             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9766           s->contents
9767             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9768         }
9769
9770       /* Figure out the size of the PLT header if we know that we
9771          are using it.  For the sake of cache alignment always use
9772          a standard header whenever any standard entries are present
9773          even if microMIPS entries are present as well.  This also
9774          lets the microMIPS header rely on the value of $v0 only set
9775          by microMIPS entries, for a small size reduction.
9776
9777          Set symbol table entry values for symbols that use the
9778          address of their PLT entry now that we can calculate it.
9779
9780          Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9781          haven't already in _bfd_elf_create_dynamic_sections.  */
9782       if (htab->root.splt && htab->plt_mips_offset + htab->plt_comp_offset != 0)
9783         {
9784           bfd_boolean micromips_p = (MICROMIPS_P (output_bfd)
9785                                      && !htab->plt_mips_offset);
9786           unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9787           bfd_vma isa_bit = micromips_p;
9788           struct elf_link_hash_entry *h;
9789           bfd_vma size;
9790
9791           BFD_ASSERT (htab->use_plts_and_copy_relocs);
9792           BFD_ASSERT (htab->root.sgotplt->size == 0);
9793           BFD_ASSERT (htab->root.splt->size == 0);
9794
9795           if (htab->is_vxworks && bfd_link_pic (info))
9796             size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
9797           else if (htab->is_vxworks)
9798             size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
9799           else if (ABI_64_P (output_bfd))
9800             size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry);
9801           else if (ABI_N32_P (output_bfd))
9802             size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry);
9803           else if (!micromips_p)
9804             size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
9805           else if (htab->insn32)
9806             size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
9807           else
9808             size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
9809
9810           htab->plt_header_is_comp = micromips_p;
9811           htab->plt_header_size = size;
9812           htab->root.splt->size = (size
9813                                    + htab->plt_mips_offset
9814                                    + htab->plt_comp_offset);
9815           htab->root.sgotplt->size = (htab->plt_got_index
9816                                       * MIPS_ELF_GOT_SIZE (dynobj));
9817
9818           mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info);
9819
9820           if (htab->root.hplt == NULL)
9821             {
9822               h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.splt,
9823                                                "_PROCEDURE_LINKAGE_TABLE_");
9824               htab->root.hplt = h;
9825               if (h == NULL)
9826                 return FALSE;
9827             }
9828
9829           h = htab->root.hplt;
9830           h->root.u.def.value = isa_bit;
9831           h->other = other;
9832           h->type = STT_FUNC;
9833         }
9834     }
9835
9836   /* Allocate space for global sym dynamic relocs.  */
9837   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9838
9839   mips_elf_estimate_stub_size (output_bfd, info);
9840
9841   if (!mips_elf_lay_out_got (output_bfd, info))
9842     return FALSE;
9843
9844   mips_elf_lay_out_lazy_stubs (info);
9845
9846   /* The check_relocs and adjust_dynamic_symbol entry points have
9847      determined the sizes of the various dynamic sections.  Allocate
9848      memory for them.  */
9849   reltext = FALSE;
9850   for (s = dynobj->sections; s != NULL; s = s->next)
9851     {
9852       const char *name;
9853
9854       /* It's OK to base decisions on the section name, because none
9855          of the dynobj section names depend upon the input files.  */
9856       name = bfd_get_section_name (dynobj, s);
9857
9858       if ((s->flags & SEC_LINKER_CREATED) == 0)
9859         continue;
9860
9861       if (CONST_STRNEQ (name, ".rel"))
9862         {
9863           if (s->size != 0)
9864             {
9865               const char *outname;
9866               asection *target;
9867
9868               /* If this relocation section applies to a read only
9869                  section, then we probably need a DT_TEXTREL entry.
9870                  If the relocation section is .rel(a).dyn, we always
9871                  assert a DT_TEXTREL entry rather than testing whether
9872                  there exists a relocation to a read only section or
9873                  not.  */
9874               outname = bfd_get_section_name (output_bfd,
9875                                               s->output_section);
9876               target = bfd_get_section_by_name (output_bfd, outname + 4);
9877               if ((target != NULL
9878                    && (target->flags & SEC_READONLY) != 0
9879                    && (target->flags & SEC_ALLOC) != 0)
9880                   || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9881                 reltext = TRUE;
9882
9883               /* We use the reloc_count field as a counter if we need
9884                  to copy relocs into the output file.  */
9885               if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9886                 s->reloc_count = 0;
9887
9888               /* If combreloc is enabled, elf_link_sort_relocs() will
9889                  sort relocations, but in a different way than we do,
9890                  and before we're done creating relocations.  Also, it
9891                  will move them around between input sections'
9892                  relocation's contents, so our sorting would be
9893                  broken, so don't let it run.  */
9894               info->combreloc = 0;
9895             }
9896         }
9897       else if (bfd_link_executable (info)
9898                && ! mips_elf_hash_table (info)->use_rld_obj_head
9899                && CONST_STRNEQ (name, ".rld_map"))
9900         {
9901           /* We add a room for __rld_map.  It will be filled in by the
9902              rtld to contain a pointer to the _r_debug structure.  */
9903           s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9904         }
9905       else if (SGI_COMPAT (output_bfd)
9906                && CONST_STRNEQ (name, ".compact_rel"))
9907         s->size += mips_elf_hash_table (info)->compact_rel_size;
9908       else if (s == htab->root.splt)
9909         {
9910           /* If the last PLT entry has a branch delay slot, allocate
9911              room for an extra nop to fill the delay slot.  This is
9912              for CPUs without load interlocking.  */
9913           if (! LOAD_INTERLOCKS_P (output_bfd)
9914               && ! htab->is_vxworks && s->size > 0)
9915             s->size += 4;
9916         }
9917       else if (! CONST_STRNEQ (name, ".init")
9918                && s != htab->root.sgot
9919                && s != htab->root.sgotplt
9920                && s != htab->sstubs
9921                && s != htab->sdynbss)
9922         {
9923           /* It's not one of our sections, so don't allocate space.  */
9924           continue;
9925         }
9926
9927       if (s->size == 0)
9928         {
9929           s->flags |= SEC_EXCLUDE;
9930           continue;
9931         }
9932
9933       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9934         continue;
9935
9936       /* Allocate memory for the section contents.  */
9937       s->contents = bfd_zalloc (dynobj, s->size);
9938       if (s->contents == NULL)
9939         {
9940           bfd_set_error (bfd_error_no_memory);
9941           return FALSE;
9942         }
9943     }
9944
9945   if (elf_hash_table (info)->dynamic_sections_created)
9946     {
9947       /* Add some entries to the .dynamic section.  We fill in the
9948          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9949          must add the entries now so that we get the correct size for
9950          the .dynamic section.  */
9951
9952       /* SGI object has the equivalence of DT_DEBUG in the
9953          DT_MIPS_RLD_MAP entry.  This must come first because glibc
9954          only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9955          may only look at the first one they see.  */
9956       if (!bfd_link_pic (info)
9957           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9958         return FALSE;
9959
9960       if (bfd_link_executable (info)
9961           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0))
9962         return FALSE;
9963
9964       /* The DT_DEBUG entry may be filled in by the dynamic linker and
9965          used by the debugger.  */
9966       if (bfd_link_executable (info)
9967           && !SGI_COMPAT (output_bfd)
9968           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9969         return FALSE;
9970
9971       if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9972         info->flags |= DF_TEXTREL;
9973
9974       if ((info->flags & DF_TEXTREL) != 0)
9975         {
9976           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9977             return FALSE;
9978
9979           /* Clear the DF_TEXTREL flag.  It will be set again if we
9980              write out an actual text relocation; we may not, because
9981              at this point we do not know whether e.g. any .eh_frame
9982              absolute relocations have been converted to PC-relative.  */
9983           info->flags &= ~DF_TEXTREL;
9984         }
9985
9986       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
9987         return FALSE;
9988
9989       sreldyn = mips_elf_rel_dyn_section (info, FALSE);
9990       if (htab->is_vxworks)
9991         {
9992           /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
9993              use any of the DT_MIPS_* tags.  */
9994           if (sreldyn && sreldyn->size > 0)
9995             {
9996               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9997                 return FALSE;
9998
9999               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
10000                 return FALSE;
10001
10002               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
10003                 return FALSE;
10004             }
10005         }
10006       else
10007         {
10008           if (sreldyn && sreldyn->size > 0)
10009             {
10010               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
10011                 return FALSE;
10012
10013               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
10014                 return FALSE;
10015
10016               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
10017                 return FALSE;
10018             }
10019
10020           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
10021             return FALSE;
10022
10023           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
10024             return FALSE;
10025
10026           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
10027             return FALSE;
10028
10029           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
10030             return FALSE;
10031
10032           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
10033             return FALSE;
10034
10035           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
10036             return FALSE;
10037
10038           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
10039             return FALSE;
10040
10041           if (IRIX_COMPAT (dynobj) == ict_irix5
10042               && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
10043             return FALSE;
10044
10045           if (IRIX_COMPAT (dynobj) == ict_irix6
10046               && (bfd_get_section_by_name
10047                   (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
10048               && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
10049             return FALSE;
10050         }
10051       if (htab->root.splt->size > 0)
10052         {
10053           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
10054             return FALSE;
10055
10056           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
10057             return FALSE;
10058
10059           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
10060             return FALSE;
10061
10062           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
10063             return FALSE;
10064         }
10065       if (htab->is_vxworks
10066           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
10067         return FALSE;
10068     }
10069
10070   return TRUE;
10071 }
10072 \f
10073 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
10074    Adjust its R_ADDEND field so that it is correct for the output file.
10075    LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
10076    and sections respectively; both use symbol indexes.  */
10077
10078 static void
10079 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
10080                         bfd *input_bfd, Elf_Internal_Sym *local_syms,
10081                         asection **local_sections, Elf_Internal_Rela *rel)
10082 {
10083   unsigned int r_type, r_symndx;
10084   Elf_Internal_Sym *sym;
10085   asection *sec;
10086
10087   if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10088     {
10089       r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10090       if (gprel16_reloc_p (r_type)
10091           || r_type == R_MIPS_GPREL32
10092           || literal_reloc_p (r_type))
10093         {
10094           rel->r_addend += _bfd_get_gp_value (input_bfd);
10095           rel->r_addend -= _bfd_get_gp_value (output_bfd);
10096         }
10097
10098       r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
10099       sym = local_syms + r_symndx;
10100
10101       /* Adjust REL's addend to account for section merging.  */
10102       if (!bfd_link_relocatable (info))
10103         {
10104           sec = local_sections[r_symndx];
10105           _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10106         }
10107
10108       /* This would normally be done by the rela_normal code in elflink.c.  */
10109       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10110         rel->r_addend += local_sections[r_symndx]->output_offset;
10111     }
10112 }
10113
10114 /* Handle relocations against symbols from removed linkonce sections,
10115    or sections discarded by a linker script.  We use this wrapper around
10116    RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
10117    on 64-bit ELF targets.  In this case for any relocation handled, which
10118    always be the first in a triplet, the remaining two have to be processed
10119    together with the first, even if they are R_MIPS_NONE.  It is the symbol
10120    index referred by the first reloc that applies to all the three and the
10121    remaining two never refer to an object symbol.  And it is the final
10122    relocation (the last non-null one) that determines the output field of
10123    the whole relocation so retrieve the corresponding howto structure for
10124    the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
10125
10126    Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
10127    and therefore requires to be pasted in a loop.  It also defines a block
10128    and does not protect any of its arguments, hence the extra brackets.  */
10129
10130 static void
10131 mips_reloc_against_discarded_section (bfd *output_bfd,
10132                                       struct bfd_link_info *info,
10133                                       bfd *input_bfd, asection *input_section,
10134                                       Elf_Internal_Rela **rel,
10135                                       const Elf_Internal_Rela **relend,
10136                                       bfd_boolean rel_reloc,
10137                                       reloc_howto_type *howto,
10138                                       bfd_byte *contents)
10139 {
10140   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10141   int count = bed->s->int_rels_per_ext_rel;
10142   unsigned int r_type;
10143   int i;
10144
10145   for (i = count - 1; i > 0; i--)
10146     {
10147       r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
10148       if (r_type != R_MIPS_NONE)
10149         {
10150           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10151           break;
10152         }
10153     }
10154   do
10155     {
10156        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
10157                                         (*rel), count, (*relend),
10158                                         howto, i, contents);
10159     }
10160   while (0);
10161 }
10162
10163 /* Relocate a MIPS ELF section.  */
10164
10165 bfd_boolean
10166 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
10167                                 bfd *input_bfd, asection *input_section,
10168                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
10169                                 Elf_Internal_Sym *local_syms,
10170                                 asection **local_sections)
10171 {
10172   Elf_Internal_Rela *rel;
10173   const Elf_Internal_Rela *relend;
10174   bfd_vma addend = 0;
10175   bfd_boolean use_saved_addend_p = FALSE;
10176   const struct elf_backend_data *bed;
10177
10178   bed = get_elf_backend_data (output_bfd);
10179   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
10180   for (rel = relocs; rel < relend; ++rel)
10181     {
10182       const char *name;
10183       bfd_vma value = 0;
10184       reloc_howto_type *howto;
10185       bfd_boolean cross_mode_jump_p = FALSE;
10186       /* TRUE if the relocation is a RELA relocation, rather than a
10187          REL relocation.  */
10188       bfd_boolean rela_relocation_p = TRUE;
10189       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10190       const char *msg;
10191       unsigned long r_symndx;
10192       asection *sec;
10193       Elf_Internal_Shdr *symtab_hdr;
10194       struct elf_link_hash_entry *h;
10195       bfd_boolean rel_reloc;
10196
10197       rel_reloc = (NEWABI_P (input_bfd)
10198                    && mips_elf_rel_relocation_p (input_bfd, input_section,
10199                                                  relocs, rel));
10200       /* Find the relocation howto for this relocation.  */
10201       howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10202
10203       r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
10204       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
10205       if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10206         {
10207           sec = local_sections[r_symndx];
10208           h = NULL;
10209         }
10210       else
10211         {
10212           unsigned long extsymoff;
10213
10214           extsymoff = 0;
10215           if (!elf_bad_symtab (input_bfd))
10216             extsymoff = symtab_hdr->sh_info;
10217           h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
10218           while (h->root.type == bfd_link_hash_indirect
10219                  || h->root.type == bfd_link_hash_warning)
10220             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10221
10222           sec = NULL;
10223           if (h->root.type == bfd_link_hash_defined
10224               || h->root.type == bfd_link_hash_defweak)
10225             sec = h->root.u.def.section;
10226         }
10227
10228       if (sec != NULL && discarded_section (sec))
10229         {
10230           mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
10231                                                 input_section, &rel, &relend,
10232                                                 rel_reloc, howto, contents);
10233           continue;
10234         }
10235
10236       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
10237         {
10238           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
10239              64-bit code, but make sure all their addresses are in the
10240              lowermost or uppermost 32-bit section of the 64-bit address
10241              space.  Thus, when they use an R_MIPS_64 they mean what is
10242              usually meant by R_MIPS_32, with the exception that the
10243              stored value is sign-extended to 64 bits.  */
10244           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
10245
10246           /* On big-endian systems, we need to lie about the position
10247              of the reloc.  */
10248           if (bfd_big_endian (input_bfd))
10249             rel->r_offset += 4;
10250         }
10251
10252       if (!use_saved_addend_p)
10253         {
10254           /* If these relocations were originally of the REL variety,
10255              we must pull the addend out of the field that will be
10256              relocated.  Otherwise, we simply use the contents of the
10257              RELA relocation.  */
10258           if (mips_elf_rel_relocation_p (input_bfd, input_section,
10259                                          relocs, rel))
10260             {
10261               rela_relocation_p = FALSE;
10262               addend = mips_elf_read_rel_addend (input_bfd, rel,
10263                                                  howto, contents);
10264               if (hi16_reloc_p (r_type)
10265                   || (got16_reloc_p (r_type)
10266                       && mips_elf_local_relocation_p (input_bfd, rel,
10267                                                       local_sections)))
10268                 {
10269                   if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
10270                                                      contents, &addend))
10271                     {
10272                       if (h)
10273                         name = h->root.root.string;
10274                       else
10275                         name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10276                                                  local_syms + r_symndx,
10277                                                  sec);
10278                       _bfd_error_handler
10279                         /* xgettext:c-format */
10280                         (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
10281                          input_bfd, input_section, name, howto->name,
10282                          rel->r_offset);
10283                     }
10284                 }
10285               else
10286                 addend <<= howto->rightshift;
10287             }
10288           else
10289             addend = rel->r_addend;
10290           mips_elf_adjust_addend (output_bfd, info, input_bfd,
10291                                   local_syms, local_sections, rel);
10292         }
10293
10294       if (bfd_link_relocatable (info))
10295         {
10296           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
10297               && bfd_big_endian (input_bfd))
10298             rel->r_offset -= 4;
10299
10300           if (!rela_relocation_p && rel->r_addend)
10301             {
10302               addend += rel->r_addend;
10303               if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
10304                 addend = mips_elf_high (addend);
10305               else if (r_type == R_MIPS_HIGHER)
10306                 addend = mips_elf_higher (addend);
10307               else if (r_type == R_MIPS_HIGHEST)
10308                 addend = mips_elf_highest (addend);
10309               else
10310                 addend >>= howto->rightshift;
10311
10312               /* We use the source mask, rather than the destination
10313                  mask because the place to which we are writing will be
10314                  source of the addend in the final link.  */
10315               addend &= howto->src_mask;
10316
10317               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10318                 /* See the comment above about using R_MIPS_64 in the 32-bit
10319                    ABI.  Here, we need to update the addend.  It would be
10320                    possible to get away with just using the R_MIPS_32 reloc
10321                    but for endianness.  */
10322                 {
10323                   bfd_vma sign_bits;
10324                   bfd_vma low_bits;
10325                   bfd_vma high_bits;
10326
10327                   if (addend & ((bfd_vma) 1 << 31))
10328 #ifdef BFD64
10329                     sign_bits = ((bfd_vma) 1 << 32) - 1;
10330 #else
10331                     sign_bits = -1;
10332 #endif
10333                   else
10334                     sign_bits = 0;
10335
10336                   /* If we don't know that we have a 64-bit type,
10337                      do two separate stores.  */
10338                   if (bfd_big_endian (input_bfd))
10339                     {
10340                       /* Store the sign-bits (which are most significant)
10341                          first.  */
10342                       low_bits = sign_bits;
10343                       high_bits = addend;
10344                     }
10345                   else
10346                     {
10347                       low_bits = addend;
10348                       high_bits = sign_bits;
10349                     }
10350                   bfd_put_32 (input_bfd, low_bits,
10351                               contents + rel->r_offset);
10352                   bfd_put_32 (input_bfd, high_bits,
10353                               contents + rel->r_offset + 4);
10354                   continue;
10355                 }
10356
10357               if (! mips_elf_perform_relocation (info, howto, rel, addend,
10358                                                  input_bfd, input_section,
10359                                                  contents, FALSE))
10360                 return FALSE;
10361             }
10362
10363           /* Go on to the next relocation.  */
10364           continue;
10365         }
10366
10367       /* In the N32 and 64-bit ABIs there may be multiple consecutive
10368          relocations for the same offset.  In that case we are
10369          supposed to treat the output of each relocation as the addend
10370          for the next.  */
10371       if (rel + 1 < relend
10372           && rel->r_offset == rel[1].r_offset
10373           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
10374         use_saved_addend_p = TRUE;
10375       else
10376         use_saved_addend_p = FALSE;
10377
10378       /* Figure out what value we are supposed to relocate.  */
10379       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
10380                                              input_section, info, rel,
10381                                              addend, howto, local_syms,
10382                                              local_sections, &value,
10383                                              &name, &cross_mode_jump_p,
10384                                              use_saved_addend_p))
10385         {
10386         case bfd_reloc_continue:
10387           /* There's nothing to do.  */
10388           continue;
10389
10390         case bfd_reloc_undefined:
10391           /* mips_elf_calculate_relocation already called the
10392              undefined_symbol callback.  There's no real point in
10393              trying to perform the relocation at this point, so we
10394              just skip ahead to the next relocation.  */
10395           continue;
10396
10397         case bfd_reloc_notsupported:
10398           msg = _("internal error: unsupported relocation error");
10399           info->callbacks->warning
10400             (info, msg, name, input_bfd, input_section, rel->r_offset);
10401           return FALSE;
10402
10403         case bfd_reloc_overflow:
10404           if (use_saved_addend_p)
10405             /* Ignore overflow until we reach the last relocation for
10406                a given location.  */
10407             ;
10408           else
10409             {
10410               struct mips_elf_link_hash_table *htab;
10411
10412               htab = mips_elf_hash_table (info);
10413               BFD_ASSERT (htab != NULL);
10414               BFD_ASSERT (name != NULL);
10415               if (!htab->small_data_overflow_reported
10416                   && (gprel16_reloc_p (howto->type)
10417                       || literal_reloc_p (howto->type)))
10418                 {
10419                   msg = _("small-data section exceeds 64KB;"
10420                           " lower small-data size limit (see option -G)");
10421
10422                   htab->small_data_overflow_reported = TRUE;
10423                   (*info->callbacks->einfo) ("%P: %s\n", msg);
10424                 }
10425               (*info->callbacks->reloc_overflow)
10426                 (info, NULL, name, howto->name, (bfd_vma) 0,
10427                  input_bfd, input_section, rel->r_offset);
10428             }
10429           break;
10430
10431         case bfd_reloc_ok:
10432           break;
10433
10434         case bfd_reloc_outofrange:
10435           msg = NULL;
10436           if (jal_reloc_p (howto->type))
10437             msg = (cross_mode_jump_p
10438                    ? _("Cannot convert a jump to JALX "
10439                        "for a non-word-aligned address")
10440                    : (howto->type == R_MIPS16_26
10441                       ? _("Jump to a non-word-aligned address")
10442                       : _("Jump to a non-instruction-aligned address")));
10443           else if (b_reloc_p (howto->type))
10444             msg = (cross_mode_jump_p
10445                    ? _("Cannot convert a branch to JALX "
10446                        "for a non-word-aligned address")
10447                    : _("Branch to a non-instruction-aligned address"));
10448           else if (aligned_pcrel_reloc_p (howto->type))
10449             msg = _("PC-relative load from unaligned address");
10450           if (msg)
10451             {
10452               info->callbacks->einfo
10453                 ("%X%H: %s\n", input_bfd, input_section, rel->r_offset, msg);
10454               break;
10455             }
10456           /* Fall through.  */
10457
10458         default:
10459           abort ();
10460           break;
10461         }
10462
10463       /* If we've got another relocation for the address, keep going
10464          until we reach the last one.  */
10465       if (use_saved_addend_p)
10466         {
10467           addend = value;
10468           continue;
10469         }
10470
10471       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10472         /* See the comment above about using R_MIPS_64 in the 32-bit
10473            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
10474            that calculated the right value.  Now, however, we
10475            sign-extend the 32-bit result to 64-bits, and store it as a
10476            64-bit value.  We are especially generous here in that we
10477            go to extreme lengths to support this usage on systems with
10478            only a 32-bit VMA.  */
10479         {
10480           bfd_vma sign_bits;
10481           bfd_vma low_bits;
10482           bfd_vma high_bits;
10483
10484           if (value & ((bfd_vma) 1 << 31))
10485 #ifdef BFD64
10486             sign_bits = ((bfd_vma) 1 << 32) - 1;
10487 #else
10488             sign_bits = -1;
10489 #endif
10490           else
10491             sign_bits = 0;
10492
10493           /* If we don't know that we have a 64-bit type,
10494              do two separate stores.  */
10495           if (bfd_big_endian (input_bfd))
10496             {
10497               /* Undo what we did above.  */
10498               rel->r_offset -= 4;
10499               /* Store the sign-bits (which are most significant)
10500                  first.  */
10501               low_bits = sign_bits;
10502               high_bits = value;
10503             }
10504           else
10505             {
10506               low_bits = value;
10507               high_bits = sign_bits;
10508             }
10509           bfd_put_32 (input_bfd, low_bits,
10510                       contents + rel->r_offset);
10511           bfd_put_32 (input_bfd, high_bits,
10512                       contents + rel->r_offset + 4);
10513           continue;
10514         }
10515
10516       /* Actually perform the relocation.  */
10517       if (! mips_elf_perform_relocation (info, howto, rel, value,
10518                                          input_bfd, input_section,
10519                                          contents, cross_mode_jump_p))
10520         return FALSE;
10521     }
10522
10523   return TRUE;
10524 }
10525 \f
10526 /* A function that iterates over each entry in la25_stubs and fills
10527    in the code for each one.  DATA points to a mips_htab_traverse_info.  */
10528
10529 static int
10530 mips_elf_create_la25_stub (void **slot, void *data)
10531 {
10532   struct mips_htab_traverse_info *hti;
10533   struct mips_elf_link_hash_table *htab;
10534   struct mips_elf_la25_stub *stub;
10535   asection *s;
10536   bfd_byte *loc;
10537   bfd_vma offset, target, target_high, target_low;
10538
10539   stub = (struct mips_elf_la25_stub *) *slot;
10540   hti = (struct mips_htab_traverse_info *) data;
10541   htab = mips_elf_hash_table (hti->info);
10542   BFD_ASSERT (htab != NULL);
10543
10544   /* Create the section contents, if we haven't already.  */
10545   s = stub->stub_section;
10546   loc = s->contents;
10547   if (loc == NULL)
10548     {
10549       loc = bfd_malloc (s->size);
10550       if (loc == NULL)
10551         {
10552           hti->error = TRUE;
10553           return FALSE;
10554         }
10555       s->contents = loc;
10556     }
10557
10558   /* Work out where in the section this stub should go.  */
10559   offset = stub->offset;
10560
10561   /* Work out the target address.  */
10562   target = mips_elf_get_la25_target (stub, &s);
10563   target += s->output_section->vma + s->output_offset;
10564
10565   target_high = ((target + 0x8000) >> 16) & 0xffff;
10566   target_low = (target & 0xffff);
10567
10568   if (stub->stub_section != htab->strampoline)
10569     {
10570       /* This is a simple LUI/ADDIU stub.  Zero out the beginning
10571          of the section and write the two instructions at the end.  */
10572       memset (loc, 0, offset);
10573       loc += offset;
10574       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10575         {
10576           bfd_put_micromips_32 (hti->output_bfd,
10577                                 LA25_LUI_MICROMIPS (target_high),
10578                                 loc);
10579           bfd_put_micromips_32 (hti->output_bfd,
10580                                 LA25_ADDIU_MICROMIPS (target_low),
10581                                 loc + 4);
10582         }
10583       else
10584         {
10585           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10586           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
10587         }
10588     }
10589   else
10590     {
10591       /* This is trampoline.  */
10592       loc += offset;
10593       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10594         {
10595           bfd_put_micromips_32 (hti->output_bfd,
10596                                 LA25_LUI_MICROMIPS (target_high), loc);
10597           bfd_put_micromips_32 (hti->output_bfd,
10598                                 LA25_J_MICROMIPS (target), loc + 4);
10599           bfd_put_micromips_32 (hti->output_bfd,
10600                                 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
10601           bfd_put_32 (hti->output_bfd, 0, loc + 12);
10602         }
10603       else
10604         {
10605           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10606           bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
10607           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
10608           bfd_put_32 (hti->output_bfd, 0, loc + 12);
10609         }
10610     }
10611   return TRUE;
10612 }
10613
10614 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10615    adjust it appropriately now.  */
10616
10617 static void
10618 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
10619                                       const char *name, Elf_Internal_Sym *sym)
10620 {
10621   /* The linker script takes care of providing names and values for
10622      these, but we must place them into the right sections.  */
10623   static const char* const text_section_symbols[] = {
10624     "_ftext",
10625     "_etext",
10626     "__dso_displacement",
10627     "__elf_header",
10628     "__program_header_table",
10629     NULL
10630   };
10631
10632   static const char* const data_section_symbols[] = {
10633     "_fdata",
10634     "_edata",
10635     "_end",
10636     "_fbss",
10637     NULL
10638   };
10639
10640   const char* const *p;
10641   int i;
10642
10643   for (i = 0; i < 2; ++i)
10644     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
10645          *p;
10646          ++p)
10647       if (strcmp (*p, name) == 0)
10648         {
10649           /* All of these symbols are given type STT_SECTION by the
10650              IRIX6 linker.  */
10651           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10652           sym->st_other = STO_PROTECTED;
10653
10654           /* The IRIX linker puts these symbols in special sections.  */
10655           if (i == 0)
10656             sym->st_shndx = SHN_MIPS_TEXT;
10657           else
10658             sym->st_shndx = SHN_MIPS_DATA;
10659
10660           break;
10661         }
10662 }
10663
10664 /* Finish up dynamic symbol handling.  We set the contents of various
10665    dynamic sections here.  */
10666
10667 bfd_boolean
10668 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
10669                                      struct bfd_link_info *info,
10670                                      struct elf_link_hash_entry *h,
10671                                      Elf_Internal_Sym *sym)
10672 {
10673   bfd *dynobj;
10674   asection *sgot;
10675   struct mips_got_info *g, *gg;
10676   const char *name;
10677   int idx;
10678   struct mips_elf_link_hash_table *htab;
10679   struct mips_elf_link_hash_entry *hmips;
10680
10681   htab = mips_elf_hash_table (info);
10682   BFD_ASSERT (htab != NULL);
10683   dynobj = elf_hash_table (info)->dynobj;
10684   hmips = (struct mips_elf_link_hash_entry *) h;
10685
10686   BFD_ASSERT (!htab->is_vxworks);
10687
10688   if (h->plt.plist != NULL
10689       && (h->plt.plist->mips_offset != MINUS_ONE
10690           || h->plt.plist->comp_offset != MINUS_ONE))
10691     {
10692       /* We've decided to create a PLT entry for this symbol.  */
10693       bfd_byte *loc;
10694       bfd_vma header_address, got_address;
10695       bfd_vma got_address_high, got_address_low, load;
10696       bfd_vma got_index;
10697       bfd_vma isa_bit;
10698
10699       got_index = h->plt.plist->gotplt_index;
10700
10701       BFD_ASSERT (htab->use_plts_and_copy_relocs);
10702       BFD_ASSERT (h->dynindx != -1);
10703       BFD_ASSERT (htab->root.splt != NULL);
10704       BFD_ASSERT (got_index != MINUS_ONE);
10705       BFD_ASSERT (!h->def_regular);
10706
10707       /* Calculate the address of the PLT header.  */
10708       isa_bit = htab->plt_header_is_comp;
10709       header_address = (htab->root.splt->output_section->vma
10710                         + htab->root.splt->output_offset + isa_bit);
10711
10712       /* Calculate the address of the .got.plt entry.  */
10713       got_address = (htab->root.sgotplt->output_section->vma
10714                      + htab->root.sgotplt->output_offset
10715                      + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10716
10717       got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10718       got_address_low = got_address & 0xffff;
10719
10720       /* Initially point the .got.plt entry at the PLT header.  */
10721       loc = (htab->root.sgotplt->contents + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10722       if (ABI_64_P (output_bfd))
10723         bfd_put_64 (output_bfd, header_address, loc);
10724       else
10725         bfd_put_32 (output_bfd, header_address, loc);
10726
10727       /* Now handle the PLT itself.  First the standard entry (the order
10728          does not matter, we just have to pick one).  */
10729       if (h->plt.plist->mips_offset != MINUS_ONE)
10730         {
10731           const bfd_vma *plt_entry;
10732           bfd_vma plt_offset;
10733
10734           plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
10735
10736           BFD_ASSERT (plt_offset <= htab->root.splt->size);
10737
10738           /* Find out where the .plt entry should go.  */
10739           loc = htab->root.splt->contents + plt_offset;
10740
10741           /* Pick the load opcode.  */
10742           load = MIPS_ELF_LOAD_WORD (output_bfd);
10743
10744           /* Fill in the PLT entry itself.  */
10745
10746           if (MIPSR6_P (output_bfd))
10747             plt_entry = mipsr6_exec_plt_entry;
10748           else
10749             plt_entry = mips_exec_plt_entry;
10750           bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
10751           bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load,
10752                       loc + 4);
10753
10754           if (! LOAD_INTERLOCKS_P (output_bfd))
10755             {
10756               bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
10757               bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10758             }
10759           else
10760             {
10761               bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
10762               bfd_put_32 (output_bfd, plt_entry[2] | got_address_low,
10763                           loc + 12);
10764             }
10765         }
10766
10767       /* Now the compressed entry.  They come after any standard ones.  */
10768       if (h->plt.plist->comp_offset != MINUS_ONE)
10769         {
10770           bfd_vma plt_offset;
10771
10772           plt_offset = (htab->plt_header_size + htab->plt_mips_offset
10773                         + h->plt.plist->comp_offset);
10774
10775           BFD_ASSERT (plt_offset <= htab->root.splt->size);
10776
10777           /* Find out where the .plt entry should go.  */
10778           loc = htab->root.splt->contents + plt_offset;
10779
10780           /* Fill in the PLT entry itself.  */
10781           if (!MICROMIPS_P (output_bfd))
10782             {
10783               const bfd_vma *plt_entry = mips16_o32_exec_plt_entry;
10784
10785               bfd_put_16 (output_bfd, plt_entry[0], loc);
10786               bfd_put_16 (output_bfd, plt_entry[1], loc + 2);
10787               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10788               bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10789               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10790               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10791               bfd_put_32 (output_bfd, got_address, loc + 12);
10792             }
10793           else if (htab->insn32)
10794             {
10795               const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry;
10796
10797               bfd_put_16 (output_bfd, plt_entry[0], loc);
10798               bfd_put_16 (output_bfd, got_address_high, loc + 2);
10799               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10800               bfd_put_16 (output_bfd, got_address_low, loc + 6);
10801               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10802               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10803               bfd_put_16 (output_bfd, plt_entry[6], loc + 12);
10804               bfd_put_16 (output_bfd, got_address_low, loc + 14);
10805             }
10806           else
10807             {
10808               const bfd_vma *plt_entry = micromips_o32_exec_plt_entry;
10809               bfd_signed_vma gotpc_offset;
10810               bfd_vma loc_address;
10811
10812               BFD_ASSERT (got_address % 4 == 0);
10813
10814               loc_address = (htab->root.splt->output_section->vma
10815                              + htab->root.splt->output_offset + plt_offset);
10816               gotpc_offset = got_address - ((loc_address | 3) ^ 3);
10817
10818               /* ADDIUPC has a span of +/-16MB, check we're in range.  */
10819               if (gotpc_offset + 0x1000000 >= 0x2000000)
10820                 {
10821                   _bfd_error_handler
10822                     /* xgettext:c-format */
10823                     (_("%B: `%A' offset of %ld from `%A' "
10824                        "beyond the range of ADDIUPC"),
10825                      output_bfd,
10826                      htab->root.sgotplt->output_section,
10827                      htab->root.splt->output_section,
10828                      (long) gotpc_offset);
10829                   bfd_set_error (bfd_error_no_error);
10830                   return FALSE;
10831                 }
10832               bfd_put_16 (output_bfd,
10833                           plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
10834               bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
10835               bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10836               bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10837               bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10838               bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10839             }
10840         }
10841
10842       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
10843       mips_elf_output_dynamic_relocation (output_bfd, htab->root.srelplt,
10844                                           got_index - 2, h->dynindx,
10845                                           R_MIPS_JUMP_SLOT, got_address);
10846
10847       /* We distinguish between PLT entries and lazy-binding stubs by
10848          giving the former an st_other value of STO_MIPS_PLT.  Set the
10849          flag and leave the value if there are any relocations in the
10850          binary where pointer equality matters.  */
10851       sym->st_shndx = SHN_UNDEF;
10852       if (h->pointer_equality_needed)
10853         sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other);
10854       else
10855         {
10856           sym->st_value = 0;
10857           sym->st_other = 0;
10858         }
10859     }
10860
10861   if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE)
10862     {
10863       /* We've decided to create a lazy-binding stub.  */
10864       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
10865       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
10866       bfd_vma stub_size = htab->function_stub_size;
10867       bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
10868       bfd_vma isa_bit = micromips_p;
10869       bfd_vma stub_big_size;
10870
10871       if (!micromips_p)
10872         stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE;
10873       else if (htab->insn32)
10874         stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE;
10875       else
10876         stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE;
10877
10878       /* This symbol has a stub.  Set it up.  */
10879
10880       BFD_ASSERT (h->dynindx != -1);
10881
10882       BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff);
10883
10884       /* Values up to 2^31 - 1 are allowed.  Larger values would cause
10885          sign extension at runtime in the stub, resulting in a negative
10886          index value.  */
10887       if (h->dynindx & ~0x7fffffff)
10888         return FALSE;
10889
10890       /* Fill the stub.  */
10891       if (micromips_p)
10892         {
10893           idx = 0;
10894           bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd),
10895                                 stub + idx);
10896           idx += 4;
10897           if (htab->insn32)
10898             {
10899               bfd_put_micromips_32 (output_bfd,
10900                                     STUB_MOVE32_MICROMIPS, stub + idx);
10901               idx += 4;
10902             }
10903           else
10904             {
10905               bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx);
10906               idx += 2;
10907             }
10908           if (stub_size == stub_big_size)
10909             {
10910               long dynindx_hi = (h->dynindx >> 16) & 0x7fff;
10911
10912               bfd_put_micromips_32 (output_bfd,
10913                                     STUB_LUI_MICROMIPS (dynindx_hi),
10914                                     stub + idx);
10915               idx += 4;
10916             }
10917           if (htab->insn32)
10918             {
10919               bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS,
10920                                     stub + idx);
10921               idx += 4;
10922             }
10923           else
10924             {
10925               bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx);
10926               idx += 2;
10927             }
10928
10929           /* If a large stub is not required and sign extension is not a
10930              problem, then use legacy code in the stub.  */
10931           if (stub_size == stub_big_size)
10932             bfd_put_micromips_32 (output_bfd,
10933                                   STUB_ORI_MICROMIPS (h->dynindx & 0xffff),
10934                                   stub + idx);
10935           else if (h->dynindx & ~0x7fff)
10936             bfd_put_micromips_32 (output_bfd,
10937                                   STUB_LI16U_MICROMIPS (h->dynindx & 0xffff),
10938                                   stub + idx);
10939           else
10940             bfd_put_micromips_32 (output_bfd,
10941                                   STUB_LI16S_MICROMIPS (output_bfd,
10942                                                         h->dynindx),
10943                                   stub + idx);
10944         }
10945       else
10946         {
10947           idx = 0;
10948           bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
10949           idx += 4;
10950           bfd_put_32 (output_bfd, STUB_MOVE, stub + idx);
10951           idx += 4;
10952           if (stub_size == stub_big_size)
10953             {
10954               bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
10955                           stub + idx);
10956               idx += 4;
10957             }
10958           bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
10959           idx += 4;
10960
10961           /* If a large stub is not required and sign extension is not a
10962              problem, then use legacy code in the stub.  */
10963           if (stub_size == stub_big_size)
10964             bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff),
10965                         stub + idx);
10966           else if (h->dynindx & ~0x7fff)
10967             bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff),
10968                         stub + idx);
10969           else
10970             bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
10971                         stub + idx);
10972         }
10973
10974       BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size);
10975       memcpy (htab->sstubs->contents + h->plt.plist->stub_offset,
10976               stub, stub_size);
10977
10978       /* Mark the symbol as undefined.  stub_offset != -1 occurs
10979          only for the referenced symbol.  */
10980       sym->st_shndx = SHN_UNDEF;
10981
10982       /* The run-time linker uses the st_value field of the symbol
10983          to reset the global offset table entry for this external
10984          to its stub address when unlinking a shared object.  */
10985       sym->st_value = (htab->sstubs->output_section->vma
10986                        + htab->sstubs->output_offset
10987                        + h->plt.plist->stub_offset
10988                        + isa_bit);
10989       sym->st_other = other;
10990     }
10991
10992   /* If we have a MIPS16 function with a stub, the dynamic symbol must
10993      refer to the stub, since only the stub uses the standard calling
10994      conventions.  */
10995   if (h->dynindx != -1 && hmips->fn_stub != NULL)
10996     {
10997       BFD_ASSERT (hmips->need_fn_stub);
10998       sym->st_value = (hmips->fn_stub->output_section->vma
10999                        + hmips->fn_stub->output_offset);
11000       sym->st_size = hmips->fn_stub->size;
11001       sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
11002     }
11003
11004   BFD_ASSERT (h->dynindx != -1
11005               || h->forced_local);
11006
11007   sgot = htab->root.sgot;
11008   g = htab->got_info;
11009   BFD_ASSERT (g != NULL);
11010
11011   /* Run through the global symbol table, creating GOT entries for all
11012      the symbols that need them.  */
11013   if (hmips->global_got_area != GGA_NONE)
11014     {
11015       bfd_vma offset;
11016       bfd_vma value;
11017
11018       value = sym->st_value;
11019       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11020       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
11021     }
11022
11023   if (hmips->global_got_area != GGA_NONE && g->next)
11024     {
11025       struct mips_got_entry e, *p;
11026       bfd_vma entry;
11027       bfd_vma offset;
11028
11029       gg = g;
11030
11031       e.abfd = output_bfd;
11032       e.symndx = -1;
11033       e.d.h = hmips;
11034       e.tls_type = GOT_TLS_NONE;
11035
11036       for (g = g->next; g->next != gg; g = g->next)
11037         {
11038           if (g->got_entries
11039               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
11040                                                            &e)))
11041             {
11042               offset = p->gotidx;
11043               BFD_ASSERT (offset > 0 && offset < htab->root.sgot->size);
11044               if (bfd_link_pic (info)
11045                   || (elf_hash_table (info)->dynamic_sections_created
11046                       && p->d.h != NULL
11047                       && p->d.h->root.def_dynamic
11048                       && !p->d.h->root.def_regular))
11049                 {
11050                   /* Create an R_MIPS_REL32 relocation for this entry.  Due to
11051                      the various compatibility problems, it's easier to mock
11052                      up an R_MIPS_32 or R_MIPS_64 relocation and leave
11053                      mips_elf_create_dynamic_relocation to calculate the
11054                      appropriate addend.  */
11055                   Elf_Internal_Rela rel[3];
11056
11057                   memset (rel, 0, sizeof (rel));
11058                   if (ABI_64_P (output_bfd))
11059                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
11060                   else
11061                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
11062                   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
11063
11064                   entry = 0;
11065                   if (! (mips_elf_create_dynamic_relocation
11066                          (output_bfd, info, rel,
11067                           e.d.h, NULL, sym->st_value, &entry, sgot)))
11068                     return FALSE;
11069                 }
11070               else
11071                 entry = sym->st_value;
11072               MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
11073             }
11074         }
11075     }
11076
11077   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
11078   name = h->root.root.string;
11079   if (h == elf_hash_table (info)->hdynamic
11080       || h == elf_hash_table (info)->hgot)
11081     sym->st_shndx = SHN_ABS;
11082   else if (strcmp (name, "_DYNAMIC_LINK") == 0
11083            || strcmp (name, "_DYNAMIC_LINKING") == 0)
11084     {
11085       sym->st_shndx = SHN_ABS;
11086       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11087       sym->st_value = 1;
11088     }
11089   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
11090     {
11091       sym->st_shndx = SHN_ABS;
11092       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11093       sym->st_value = elf_gp (output_bfd);
11094     }
11095   else if (SGI_COMPAT (output_bfd))
11096     {
11097       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
11098           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
11099         {
11100           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11101           sym->st_other = STO_PROTECTED;
11102           sym->st_value = 0;
11103           sym->st_shndx = SHN_MIPS_DATA;
11104         }
11105       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
11106         {
11107           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11108           sym->st_other = STO_PROTECTED;
11109           sym->st_value = mips_elf_hash_table (info)->procedure_count;
11110           sym->st_shndx = SHN_ABS;
11111         }
11112       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
11113         {
11114           if (h->type == STT_FUNC)
11115             sym->st_shndx = SHN_MIPS_TEXT;
11116           else if (h->type == STT_OBJECT)
11117             sym->st_shndx = SHN_MIPS_DATA;
11118         }
11119     }
11120
11121   /* Emit a copy reloc, if needed.  */
11122   if (h->needs_copy)
11123     {
11124       asection *s;
11125       bfd_vma symval;
11126
11127       BFD_ASSERT (h->dynindx != -1);
11128       BFD_ASSERT (htab->use_plts_and_copy_relocs);
11129
11130       s = mips_elf_rel_dyn_section (info, FALSE);
11131       symval = (h->root.u.def.section->output_section->vma
11132                 + h->root.u.def.section->output_offset
11133                 + h->root.u.def.value);
11134       mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
11135                                           h->dynindx, R_MIPS_COPY, symval);
11136     }
11137
11138   /* Handle the IRIX6-specific symbols.  */
11139   if (IRIX_COMPAT (output_bfd) == ict_irix6)
11140     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
11141
11142   /* Keep dynamic compressed symbols odd.  This allows the dynamic linker
11143      to treat compressed symbols like any other.  */
11144   if (ELF_ST_IS_MIPS16 (sym->st_other))
11145     {
11146       BFD_ASSERT (sym->st_value & 1);
11147       sym->st_other -= STO_MIPS16;
11148     }
11149   else if (ELF_ST_IS_MICROMIPS (sym->st_other))
11150     {
11151       BFD_ASSERT (sym->st_value & 1);
11152       sym->st_other -= STO_MICROMIPS;
11153     }
11154
11155   return TRUE;
11156 }
11157
11158 /* Likewise, for VxWorks.  */
11159
11160 bfd_boolean
11161 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
11162                                          struct bfd_link_info *info,
11163                                          struct elf_link_hash_entry *h,
11164                                          Elf_Internal_Sym *sym)
11165 {
11166   bfd *dynobj;
11167   asection *sgot;
11168   struct mips_got_info *g;
11169   struct mips_elf_link_hash_table *htab;
11170   struct mips_elf_link_hash_entry *hmips;
11171
11172   htab = mips_elf_hash_table (info);
11173   BFD_ASSERT (htab != NULL);
11174   dynobj = elf_hash_table (info)->dynobj;
11175   hmips = (struct mips_elf_link_hash_entry *) h;
11176
11177   if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE)
11178     {
11179       bfd_byte *loc;
11180       bfd_vma plt_address, got_address, got_offset, branch_offset;
11181       Elf_Internal_Rela rel;
11182       static const bfd_vma *plt_entry;
11183       bfd_vma gotplt_index;
11184       bfd_vma plt_offset;
11185
11186       plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
11187       gotplt_index = h->plt.plist->gotplt_index;
11188
11189       BFD_ASSERT (h->dynindx != -1);
11190       BFD_ASSERT (htab->root.splt != NULL);
11191       BFD_ASSERT (gotplt_index != MINUS_ONE);
11192       BFD_ASSERT (plt_offset <= htab->root.splt->size);
11193
11194       /* Calculate the address of the .plt entry.  */
11195       plt_address = (htab->root.splt->output_section->vma
11196                      + htab->root.splt->output_offset
11197                      + plt_offset);
11198
11199       /* Calculate the address of the .got.plt entry.  */
11200       got_address = (htab->root.sgotplt->output_section->vma
11201                      + htab->root.sgotplt->output_offset
11202                      + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd));
11203
11204       /* Calculate the offset of the .got.plt entry from
11205          _GLOBAL_OFFSET_TABLE_.  */
11206       got_offset = mips_elf_gotplt_index (info, h);
11207
11208       /* Calculate the offset for the branch at the start of the PLT
11209          entry.  The branch jumps to the beginning of .plt.  */
11210       branch_offset = -(plt_offset / 4 + 1) & 0xffff;
11211
11212       /* Fill in the initial value of the .got.plt entry.  */
11213       bfd_put_32 (output_bfd, plt_address,
11214                   (htab->root.sgotplt->contents
11215                    + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)));
11216
11217       /* Find out where the .plt entry should go.  */
11218       loc = htab->root.splt->contents + plt_offset;
11219
11220       if (bfd_link_pic (info))
11221         {
11222           plt_entry = mips_vxworks_shared_plt_entry;
11223           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11224           bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11225         }
11226       else
11227         {
11228           bfd_vma got_address_high, got_address_low;
11229
11230           plt_entry = mips_vxworks_exec_plt_entry;
11231           got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
11232           got_address_low = got_address & 0xffff;
11233
11234           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11235           bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11236           bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
11237           bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
11238           bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11239           bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11240           bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11241           bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11242
11243           loc = (htab->srelplt2->contents
11244                  + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela));
11245
11246           /* Emit a relocation for the .got.plt entry.  */
11247           rel.r_offset = got_address;
11248           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11249           rel.r_addend = plt_offset;
11250           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11251
11252           /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
11253           loc += sizeof (Elf32_External_Rela);
11254           rel.r_offset = plt_address + 8;
11255           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11256           rel.r_addend = got_offset;
11257           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11258
11259           /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
11260           loc += sizeof (Elf32_External_Rela);
11261           rel.r_offset += 4;
11262           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11263           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11264         }
11265
11266       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
11267       loc = (htab->root.srelplt->contents
11268              + gotplt_index * sizeof (Elf32_External_Rela));
11269       rel.r_offset = got_address;
11270       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
11271       rel.r_addend = 0;
11272       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11273
11274       if (!h->def_regular)
11275         sym->st_shndx = SHN_UNDEF;
11276     }
11277
11278   BFD_ASSERT (h->dynindx != -1 || h->forced_local);
11279
11280   sgot = htab->root.sgot;
11281   g = htab->got_info;
11282   BFD_ASSERT (g != NULL);
11283
11284   /* See if this symbol has an entry in the GOT.  */
11285   if (hmips->global_got_area != GGA_NONE)
11286     {
11287       bfd_vma offset;
11288       Elf_Internal_Rela outrel;
11289       bfd_byte *loc;
11290       asection *s;
11291
11292       /* Install the symbol value in the GOT.   */
11293       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11294       MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
11295
11296       /* Add a dynamic relocation for it.  */
11297       s = mips_elf_rel_dyn_section (info, FALSE);
11298       loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
11299       outrel.r_offset = (sgot->output_section->vma
11300                          + sgot->output_offset
11301                          + offset);
11302       outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
11303       outrel.r_addend = 0;
11304       bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
11305     }
11306
11307   /* Emit a copy reloc, if needed.  */
11308   if (h->needs_copy)
11309     {
11310       Elf_Internal_Rela rel;
11311
11312       BFD_ASSERT (h->dynindx != -1);
11313
11314       rel.r_offset = (h->root.u.def.section->output_section->vma
11315                       + h->root.u.def.section->output_offset
11316                       + h->root.u.def.value);
11317       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
11318       rel.r_addend = 0;
11319       bfd_elf32_swap_reloca_out (output_bfd, &rel,
11320                                  htab->srelbss->contents
11321                                  + (htab->srelbss->reloc_count
11322                                     * sizeof (Elf32_External_Rela)));
11323       ++htab->srelbss->reloc_count;
11324     }
11325
11326   /* If this is a mips16/microMIPS symbol, force the value to be even.  */
11327   if (ELF_ST_IS_COMPRESSED (sym->st_other))
11328     sym->st_value &= ~1;
11329
11330   return TRUE;
11331 }
11332
11333 /* Write out a plt0 entry to the beginning of .plt.  */
11334
11335 static bfd_boolean
11336 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11337 {
11338   bfd_byte *loc;
11339   bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
11340   static const bfd_vma *plt_entry;
11341   struct mips_elf_link_hash_table *htab;
11342
11343   htab = mips_elf_hash_table (info);
11344   BFD_ASSERT (htab != NULL);
11345
11346   if (ABI_64_P (output_bfd))
11347     plt_entry = mips_n64_exec_plt0_entry;
11348   else if (ABI_N32_P (output_bfd))
11349     plt_entry = mips_n32_exec_plt0_entry;
11350   else if (!htab->plt_header_is_comp)
11351     plt_entry = mips_o32_exec_plt0_entry;
11352   else if (htab->insn32)
11353     plt_entry = micromips_insn32_o32_exec_plt0_entry;
11354   else
11355     plt_entry = micromips_o32_exec_plt0_entry;
11356
11357   /* Calculate the value of .got.plt.  */
11358   gotplt_value = (htab->root.sgotplt->output_section->vma
11359                   + htab->root.sgotplt->output_offset);
11360   gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
11361   gotplt_value_low = gotplt_value & 0xffff;
11362
11363   /* The PLT sequence is not safe for N64 if .got.plt's address can
11364      not be loaded in two instructions.  */
11365   BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
11366               || ~(gotplt_value | 0x7fffffff) == 0);
11367
11368   /* Install the PLT header.  */
11369   loc = htab->root.splt->contents;
11370   if (plt_entry == micromips_o32_exec_plt0_entry)
11371     {
11372       bfd_vma gotpc_offset;
11373       bfd_vma loc_address;
11374       size_t i;
11375
11376       BFD_ASSERT (gotplt_value % 4 == 0);
11377
11378       loc_address = (htab->root.splt->output_section->vma
11379                      + htab->root.splt->output_offset);
11380       gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3);
11381
11382       /* ADDIUPC has a span of +/-16MB, check we're in range.  */
11383       if (gotpc_offset + 0x1000000 >= 0x2000000)
11384         {
11385           _bfd_error_handler
11386             /* xgettext:c-format */
11387             (_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
11388              output_bfd,
11389              htab->root.sgotplt->output_section,
11390              htab->root.splt->output_section,
11391              (long) gotpc_offset);
11392           bfd_set_error (bfd_error_no_error);
11393           return FALSE;
11394         }
11395       bfd_put_16 (output_bfd,
11396                   plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
11397       bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
11398       for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++)
11399         bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11400     }
11401   else if (plt_entry == micromips_insn32_o32_exec_plt0_entry)
11402     {
11403       size_t i;
11404
11405       bfd_put_16 (output_bfd, plt_entry[0], loc);
11406       bfd_put_16 (output_bfd, gotplt_value_high, loc + 2);
11407       bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
11408       bfd_put_16 (output_bfd, gotplt_value_low, loc + 6);
11409       bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
11410       bfd_put_16 (output_bfd, gotplt_value_low, loc + 10);
11411       for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++)
11412         bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11413     }
11414   else
11415     {
11416       bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
11417       bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
11418       bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
11419       bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11420       bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11421       bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11422       bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11423       bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11424     }
11425
11426   return TRUE;
11427 }
11428
11429 /* Install the PLT header for a VxWorks executable and finalize the
11430    contents of .rela.plt.unloaded.  */
11431
11432 static void
11433 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11434 {
11435   Elf_Internal_Rela rela;
11436   bfd_byte *loc;
11437   bfd_vma got_value, got_value_high, got_value_low, plt_address;
11438   static const bfd_vma *plt_entry;
11439   struct mips_elf_link_hash_table *htab;
11440
11441   htab = mips_elf_hash_table (info);
11442   BFD_ASSERT (htab != NULL);
11443
11444   plt_entry = mips_vxworks_exec_plt0_entry;
11445
11446   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
11447   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
11448                + htab->root.hgot->root.u.def.section->output_offset
11449                + htab->root.hgot->root.u.def.value);
11450
11451   got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
11452   got_value_low = got_value & 0xffff;
11453
11454   /* Calculate the address of the PLT header.  */
11455   plt_address = (htab->root.splt->output_section->vma
11456                  + htab->root.splt->output_offset);
11457
11458   /* Install the PLT header.  */
11459   loc = htab->root.splt->contents;
11460   bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
11461   bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
11462   bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
11463   bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11464   bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11465   bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11466
11467   /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
11468   loc = htab->srelplt2->contents;
11469   rela.r_offset = plt_address;
11470   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11471   rela.r_addend = 0;
11472   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11473   loc += sizeof (Elf32_External_Rela);
11474
11475   /* Output the relocation for the following addiu of
11476      %lo(_GLOBAL_OFFSET_TABLE_).  */
11477   rela.r_offset += 4;
11478   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11479   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11480   loc += sizeof (Elf32_External_Rela);
11481
11482   /* Fix up the remaining relocations.  They may have the wrong
11483      symbol index for _G_O_T_ or _P_L_T_ depending on the order
11484      in which symbols were output.  */
11485   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
11486     {
11487       Elf_Internal_Rela rel;
11488
11489       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11490       rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11491       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11492       loc += sizeof (Elf32_External_Rela);
11493
11494       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11495       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11496       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11497       loc += sizeof (Elf32_External_Rela);
11498
11499       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11500       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11501       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11502       loc += sizeof (Elf32_External_Rela);
11503     }
11504 }
11505
11506 /* Install the PLT header for a VxWorks shared library.  */
11507
11508 static void
11509 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
11510 {
11511   unsigned int i;
11512   struct mips_elf_link_hash_table *htab;
11513
11514   htab = mips_elf_hash_table (info);
11515   BFD_ASSERT (htab != NULL);
11516
11517   /* We just need to copy the entry byte-by-byte.  */
11518   for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
11519     bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
11520                 htab->root.splt->contents + i * 4);
11521 }
11522
11523 /* Finish up the dynamic sections.  */
11524
11525 bfd_boolean
11526 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
11527                                        struct bfd_link_info *info)
11528 {
11529   bfd *dynobj;
11530   asection *sdyn;
11531   asection *sgot;
11532   struct mips_got_info *gg, *g;
11533   struct mips_elf_link_hash_table *htab;
11534
11535   htab = mips_elf_hash_table (info);
11536   BFD_ASSERT (htab != NULL);
11537
11538   dynobj = elf_hash_table (info)->dynobj;
11539
11540   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
11541
11542   sgot = htab->root.sgot;
11543   gg = htab->got_info;
11544
11545   if (elf_hash_table (info)->dynamic_sections_created)
11546     {
11547       bfd_byte *b;
11548       int dyn_to_skip = 0, dyn_skipped = 0;
11549
11550       BFD_ASSERT (sdyn != NULL);
11551       BFD_ASSERT (gg != NULL);
11552
11553       g = mips_elf_bfd_got (output_bfd, FALSE);
11554       BFD_ASSERT (g != NULL);
11555
11556       for (b = sdyn->contents;
11557            b < sdyn->contents + sdyn->size;
11558            b += MIPS_ELF_DYN_SIZE (dynobj))
11559         {
11560           Elf_Internal_Dyn dyn;
11561           const char *name;
11562           size_t elemsize;
11563           asection *s;
11564           bfd_boolean swap_out_p;
11565
11566           /* Read in the current dynamic entry.  */
11567           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11568
11569           /* Assume that we're going to modify it and write it out.  */
11570           swap_out_p = TRUE;
11571
11572           switch (dyn.d_tag)
11573             {
11574             case DT_RELENT:
11575               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
11576               break;
11577
11578             case DT_RELAENT:
11579               BFD_ASSERT (htab->is_vxworks);
11580               dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
11581               break;
11582
11583             case DT_STRSZ:
11584               /* Rewrite DT_STRSZ.  */
11585               dyn.d_un.d_val =
11586                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
11587               break;
11588
11589             case DT_PLTGOT:
11590               s = htab->root.sgot;
11591               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11592               break;
11593
11594             case DT_MIPS_PLTGOT:
11595               s = htab->root.sgotplt;
11596               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11597               break;
11598
11599             case DT_MIPS_RLD_VERSION:
11600               dyn.d_un.d_val = 1; /* XXX */
11601               break;
11602
11603             case DT_MIPS_FLAGS:
11604               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
11605               break;
11606
11607             case DT_MIPS_TIME_STAMP:
11608               {
11609                 time_t t;
11610                 time (&t);
11611                 dyn.d_un.d_val = t;
11612               }
11613               break;
11614
11615             case DT_MIPS_ICHECKSUM:
11616               /* XXX FIXME: */
11617               swap_out_p = FALSE;
11618               break;
11619
11620             case DT_MIPS_IVERSION:
11621               /* XXX FIXME: */
11622               swap_out_p = FALSE;
11623               break;
11624
11625             case DT_MIPS_BASE_ADDRESS:
11626               s = output_bfd->sections;
11627               BFD_ASSERT (s != NULL);
11628               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
11629               break;
11630
11631             case DT_MIPS_LOCAL_GOTNO:
11632               dyn.d_un.d_val = g->local_gotno;
11633               break;
11634
11635             case DT_MIPS_UNREFEXTNO:
11636               /* The index into the dynamic symbol table which is the
11637                  entry of the first external symbol that is not
11638                  referenced within the same object.  */
11639               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
11640               break;
11641
11642             case DT_MIPS_GOTSYM:
11643               if (htab->global_gotsym)
11644                 {
11645                   dyn.d_un.d_val = htab->global_gotsym->dynindx;
11646                   break;
11647                 }
11648               /* In case if we don't have global got symbols we default
11649                  to setting DT_MIPS_GOTSYM to the same value as
11650                  DT_MIPS_SYMTABNO.  */
11651               /* Fall through.  */
11652
11653             case DT_MIPS_SYMTABNO:
11654               name = ".dynsym";
11655               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
11656               s = bfd_get_linker_section (dynobj, name);
11657
11658               if (s != NULL)
11659                 dyn.d_un.d_val = s->size / elemsize;
11660               else
11661                 dyn.d_un.d_val = 0;
11662               break;
11663
11664             case DT_MIPS_HIPAGENO:
11665               dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
11666               break;
11667
11668             case DT_MIPS_RLD_MAP:
11669               {
11670                 struct elf_link_hash_entry *h;
11671                 h = mips_elf_hash_table (info)->rld_symbol;
11672                 if (!h)
11673                   {
11674                     dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11675                     swap_out_p = FALSE;
11676                     break;
11677                   }
11678                 s = h->root.u.def.section;
11679
11680                 /* The MIPS_RLD_MAP tag stores the absolute address of the
11681                    debug pointer.  */
11682                 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
11683                                   + h->root.u.def.value);
11684               }
11685               break;
11686
11687             case DT_MIPS_RLD_MAP_REL:
11688               {
11689                 struct elf_link_hash_entry *h;
11690                 bfd_vma dt_addr, rld_addr;
11691                 h = mips_elf_hash_table (info)->rld_symbol;
11692                 if (!h)
11693                   {
11694                     dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11695                     swap_out_p = FALSE;
11696                     break;
11697                   }
11698                 s = h->root.u.def.section;
11699
11700                 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11701                    pointer, relative to the address of the tag.  */
11702                 dt_addr = (sdyn->output_section->vma + sdyn->output_offset
11703                            + (b - sdyn->contents));
11704                 rld_addr = (s->output_section->vma + s->output_offset
11705                             + h->root.u.def.value);
11706                 dyn.d_un.d_ptr = rld_addr - dt_addr;
11707               }
11708               break;
11709
11710             case DT_MIPS_OPTIONS:
11711               s = (bfd_get_section_by_name
11712                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
11713               dyn.d_un.d_ptr = s->vma;
11714               break;
11715
11716             case DT_PLTREL:
11717               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11718               if (htab->is_vxworks)
11719                 dyn.d_un.d_val = DT_RELA;
11720               else
11721                 dyn.d_un.d_val = DT_REL;
11722               break;
11723
11724             case DT_PLTRELSZ:
11725               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11726               dyn.d_un.d_val = htab->root.srelplt->size;
11727               break;
11728
11729             case DT_JMPREL:
11730               BFD_ASSERT (htab->use_plts_and_copy_relocs);
11731               dyn.d_un.d_ptr = (htab->root.srelplt->output_section->vma
11732                                 + htab->root.srelplt->output_offset);
11733               break;
11734
11735             case DT_TEXTREL:
11736               /* If we didn't need any text relocations after all, delete
11737                  the dynamic tag.  */
11738               if (!(info->flags & DF_TEXTREL))
11739                 {
11740                   dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11741                   swap_out_p = FALSE;
11742                 }
11743               break;
11744
11745             case DT_FLAGS:
11746               /* If we didn't need any text relocations after all, clear
11747                  DF_TEXTREL from DT_FLAGS.  */
11748               if (!(info->flags & DF_TEXTREL))
11749                 dyn.d_un.d_val &= ~DF_TEXTREL;
11750               else
11751                 swap_out_p = FALSE;
11752               break;
11753
11754             default:
11755               swap_out_p = FALSE;
11756               if (htab->is_vxworks
11757                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
11758                 swap_out_p = TRUE;
11759               break;
11760             }
11761
11762           if (swap_out_p || dyn_skipped)
11763             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11764               (dynobj, &dyn, b - dyn_skipped);
11765
11766           if (dyn_to_skip)
11767             {
11768               dyn_skipped += dyn_to_skip;
11769               dyn_to_skip = 0;
11770             }
11771         }
11772
11773       /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
11774       if (dyn_skipped > 0)
11775         memset (b - dyn_skipped, 0, dyn_skipped);
11776     }
11777
11778   if (sgot != NULL && sgot->size > 0
11779       && !bfd_is_abs_section (sgot->output_section))
11780     {
11781       if (htab->is_vxworks)
11782         {
11783           /* The first entry of the global offset table points to the
11784              ".dynamic" section.  The second is initialized by the
11785              loader and contains the shared library identifier.
11786              The third is also initialized by the loader and points
11787              to the lazy resolution stub.  */
11788           MIPS_ELF_PUT_WORD (output_bfd,
11789                              sdyn->output_offset + sdyn->output_section->vma,
11790                              sgot->contents);
11791           MIPS_ELF_PUT_WORD (output_bfd, 0,
11792                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11793           MIPS_ELF_PUT_WORD (output_bfd, 0,
11794                              sgot->contents
11795                              + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
11796         }
11797       else
11798         {
11799           /* The first entry of the global offset table will be filled at
11800              runtime. The second entry will be used by some runtime loaders.
11801              This isn't the case of IRIX rld.  */
11802           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
11803           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11804                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11805         }
11806
11807       elf_section_data (sgot->output_section)->this_hdr.sh_entsize
11808          = MIPS_ELF_GOT_SIZE (output_bfd);
11809     }
11810
11811   /* Generate dynamic relocations for the non-primary gots.  */
11812   if (gg != NULL && gg->next)
11813     {
11814       Elf_Internal_Rela rel[3];
11815       bfd_vma addend = 0;
11816
11817       memset (rel, 0, sizeof (rel));
11818       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
11819
11820       for (g = gg->next; g->next != gg; g = g->next)
11821         {
11822           bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
11823             + g->next->tls_gotno;
11824
11825           MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
11826                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11827           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11828                              sgot->contents
11829                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11830
11831           if (! bfd_link_pic (info))
11832             continue;
11833
11834           for (; got_index < g->local_gotno; got_index++)
11835             {
11836               if (got_index >= g->assigned_low_gotno
11837                   && got_index <= g->assigned_high_gotno)
11838                 continue;
11839
11840               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
11841                 = got_index * MIPS_ELF_GOT_SIZE (output_bfd);
11842               if (!(mips_elf_create_dynamic_relocation
11843                     (output_bfd, info, rel, NULL,
11844                      bfd_abs_section_ptr,
11845                      0, &addend, sgot)))
11846                 return FALSE;
11847               BFD_ASSERT (addend == 0);
11848             }
11849         }
11850     }
11851
11852   /* The generation of dynamic relocations for the non-primary gots
11853      adds more dynamic relocations.  We cannot count them until
11854      here.  */
11855
11856   if (elf_hash_table (info)->dynamic_sections_created)
11857     {
11858       bfd_byte *b;
11859       bfd_boolean swap_out_p;
11860
11861       BFD_ASSERT (sdyn != NULL);
11862
11863       for (b = sdyn->contents;
11864            b < sdyn->contents + sdyn->size;
11865            b += MIPS_ELF_DYN_SIZE (dynobj))
11866         {
11867           Elf_Internal_Dyn dyn;
11868           asection *s;
11869
11870           /* Read in the current dynamic entry.  */
11871           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11872
11873           /* Assume that we're going to modify it and write it out.  */
11874           swap_out_p = TRUE;
11875
11876           switch (dyn.d_tag)
11877             {
11878             case DT_RELSZ:
11879               /* Reduce DT_RELSZ to account for any relocations we
11880                  decided not to make.  This is for the n64 irix rld,
11881                  which doesn't seem to apply any relocations if there
11882                  are trailing null entries.  */
11883               s = mips_elf_rel_dyn_section (info, FALSE);
11884               dyn.d_un.d_val = (s->reloc_count
11885                                 * (ABI_64_P (output_bfd)
11886                                    ? sizeof (Elf64_Mips_External_Rel)
11887                                    : sizeof (Elf32_External_Rel)));
11888               /* Adjust the section size too.  Tools like the prelinker
11889                  can reasonably expect the values to the same.  */
11890               elf_section_data (s->output_section)->this_hdr.sh_size
11891                 = dyn.d_un.d_val;
11892               break;
11893
11894             default:
11895               swap_out_p = FALSE;
11896               break;
11897             }
11898
11899           if (swap_out_p)
11900             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11901               (dynobj, &dyn, b);
11902         }
11903     }
11904
11905   {
11906     asection *s;
11907     Elf32_compact_rel cpt;
11908
11909     if (SGI_COMPAT (output_bfd))
11910       {
11911         /* Write .compact_rel section out.  */
11912         s = bfd_get_linker_section (dynobj, ".compact_rel");
11913         if (s != NULL)
11914           {
11915             cpt.id1 = 1;
11916             cpt.num = s->reloc_count;
11917             cpt.id2 = 2;
11918             cpt.offset = (s->output_section->filepos
11919                           + sizeof (Elf32_External_compact_rel));
11920             cpt.reserved0 = 0;
11921             cpt.reserved1 = 0;
11922             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
11923                                             ((Elf32_External_compact_rel *)
11924                                              s->contents));
11925
11926             /* Clean up a dummy stub function entry in .text.  */
11927             if (htab->sstubs != NULL)
11928               {
11929                 file_ptr dummy_offset;
11930
11931                 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
11932                 dummy_offset = htab->sstubs->size - htab->function_stub_size;
11933                 memset (htab->sstubs->contents + dummy_offset, 0,
11934                         htab->function_stub_size);
11935               }
11936           }
11937       }
11938
11939     /* The psABI says that the dynamic relocations must be sorted in
11940        increasing order of r_symndx.  The VxWorks EABI doesn't require
11941        this, and because the code below handles REL rather than RELA
11942        relocations, using it for VxWorks would be outright harmful.  */
11943     if (!htab->is_vxworks)
11944       {
11945         s = mips_elf_rel_dyn_section (info, FALSE);
11946         if (s != NULL
11947             && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
11948           {
11949             reldyn_sorting_bfd = output_bfd;
11950
11951             if (ABI_64_P (output_bfd))
11952               qsort ((Elf64_External_Rel *) s->contents + 1,
11953                      s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
11954                      sort_dynamic_relocs_64);
11955             else
11956               qsort ((Elf32_External_Rel *) s->contents + 1,
11957                      s->reloc_count - 1, sizeof (Elf32_External_Rel),
11958                      sort_dynamic_relocs);
11959           }
11960       }
11961   }
11962
11963   if (htab->root.splt && htab->root.splt->size > 0)
11964     {
11965       if (htab->is_vxworks)
11966         {
11967           if (bfd_link_pic (info))
11968             mips_vxworks_finish_shared_plt (output_bfd, info);
11969           else
11970             mips_vxworks_finish_exec_plt (output_bfd, info);
11971         }
11972       else
11973         {
11974           BFD_ASSERT (!bfd_link_pic (info));
11975           if (!mips_finish_exec_plt (output_bfd, info))
11976             return FALSE;
11977         }
11978     }
11979   return TRUE;
11980 }
11981
11982
11983 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
11984
11985 static void
11986 mips_set_isa_flags (bfd *abfd)
11987 {
11988   flagword val;
11989
11990   switch (bfd_get_mach (abfd))
11991     {
11992     default:
11993     case bfd_mach_mips3000:
11994       val = E_MIPS_ARCH_1;
11995       break;
11996
11997     case bfd_mach_mips3900:
11998       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
11999       break;
12000
12001     case bfd_mach_mips6000:
12002       val = E_MIPS_ARCH_2;
12003       break;
12004
12005     case bfd_mach_mips4000:
12006     case bfd_mach_mips4300:
12007     case bfd_mach_mips4400:
12008     case bfd_mach_mips4600:
12009       val = E_MIPS_ARCH_3;
12010       break;
12011
12012     case bfd_mach_mips4010:
12013       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
12014       break;
12015
12016     case bfd_mach_mips4100:
12017       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
12018       break;
12019
12020     case bfd_mach_mips4111:
12021       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
12022       break;
12023
12024     case bfd_mach_mips4120:
12025       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
12026       break;
12027
12028     case bfd_mach_mips4650:
12029       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
12030       break;
12031
12032     case bfd_mach_mips5400:
12033       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
12034       break;
12035
12036     case bfd_mach_mips5500:
12037       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
12038       break;
12039
12040     case bfd_mach_mips5900:
12041       val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
12042       break;
12043
12044     case bfd_mach_mips9000:
12045       val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
12046       break;
12047
12048     case bfd_mach_mips5000:
12049     case bfd_mach_mips7000:
12050     case bfd_mach_mips8000:
12051     case bfd_mach_mips10000:
12052     case bfd_mach_mips12000:
12053     case bfd_mach_mips14000:
12054     case bfd_mach_mips16000:
12055       val = E_MIPS_ARCH_4;
12056       break;
12057
12058     case bfd_mach_mips5:
12059       val = E_MIPS_ARCH_5;
12060       break;
12061
12062     case bfd_mach_mips_loongson_2e:
12063       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
12064       break;
12065
12066     case bfd_mach_mips_loongson_2f:
12067       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
12068       break;
12069
12070     case bfd_mach_mips_sb1:
12071       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
12072       break;
12073
12074     case bfd_mach_mips_loongson_3a:
12075       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_LS3A;
12076       break;
12077
12078     case bfd_mach_mips_octeon:
12079     case bfd_mach_mips_octeonp:
12080       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
12081       break;
12082
12083     case bfd_mach_mips_octeon3:
12084       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3;
12085       break;
12086
12087     case bfd_mach_mips_xlr:
12088       val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
12089       break;
12090
12091     case bfd_mach_mips_octeon2:
12092       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
12093       break;
12094
12095     case bfd_mach_mipsisa32:
12096       val = E_MIPS_ARCH_32;
12097       break;
12098
12099     case bfd_mach_mipsisa64:
12100       val = E_MIPS_ARCH_64;
12101       break;
12102
12103     case bfd_mach_mipsisa32r2:
12104     case bfd_mach_mipsisa32r3:
12105     case bfd_mach_mipsisa32r5:
12106       val = E_MIPS_ARCH_32R2;
12107       break;
12108
12109     case bfd_mach_mipsisa64r2:
12110     case bfd_mach_mipsisa64r3:
12111     case bfd_mach_mipsisa64r5:
12112       val = E_MIPS_ARCH_64R2;
12113       break;
12114
12115     case bfd_mach_mipsisa32r6:
12116       val = E_MIPS_ARCH_32R6;
12117       break;
12118
12119     case bfd_mach_mipsisa64r6:
12120       val = E_MIPS_ARCH_64R6;
12121       break;
12122     }
12123   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
12124   elf_elfheader (abfd)->e_flags |= val;
12125
12126 }
12127
12128
12129 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
12130    Don't do so for code sections.  We want to keep ordering of HI16/LO16
12131    as is.  On the other hand, elf-eh-frame.c processing requires .eh_frame
12132    relocs to be sorted.  */
12133
12134 bfd_boolean
12135 _bfd_mips_elf_sort_relocs_p (asection *sec)
12136 {
12137   return (sec->flags & SEC_CODE) == 0;
12138 }
12139
12140
12141 /* The final processing done just before writing out a MIPS ELF object
12142    file.  This gets the MIPS architecture right based on the machine
12143    number.  This is used by both the 32-bit and the 64-bit ABI.  */
12144
12145 void
12146 _bfd_mips_elf_final_write_processing (bfd *abfd,
12147                                       bfd_boolean linker ATTRIBUTE_UNUSED)
12148 {
12149   unsigned int i;
12150   Elf_Internal_Shdr **hdrpp;
12151   const char *name;
12152   asection *sec;
12153
12154   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
12155      is nonzero.  This is for compatibility with old objects, which used
12156      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
12157   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
12158     mips_set_isa_flags (abfd);
12159
12160   /* Set the sh_info field for .gptab sections and other appropriate
12161      info for each special section.  */
12162   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
12163        i < elf_numsections (abfd);
12164        i++, hdrpp++)
12165     {
12166       switch ((*hdrpp)->sh_type)
12167         {
12168         case SHT_MIPS_MSYM:
12169         case SHT_MIPS_LIBLIST:
12170           sec = bfd_get_section_by_name (abfd, ".dynstr");
12171           if (sec != NULL)
12172             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12173           break;
12174
12175         case SHT_MIPS_GPTAB:
12176           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12177           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12178           BFD_ASSERT (name != NULL
12179                       && CONST_STRNEQ (name, ".gptab."));
12180           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
12181           BFD_ASSERT (sec != NULL);
12182           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12183           break;
12184
12185         case SHT_MIPS_CONTENT:
12186           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12187           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12188           BFD_ASSERT (name != NULL
12189                       && CONST_STRNEQ (name, ".MIPS.content"));
12190           sec = bfd_get_section_by_name (abfd,
12191                                          name + sizeof ".MIPS.content" - 1);
12192           BFD_ASSERT (sec != NULL);
12193           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12194           break;
12195
12196         case SHT_MIPS_SYMBOL_LIB:
12197           sec = bfd_get_section_by_name (abfd, ".dynsym");
12198           if (sec != NULL)
12199             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12200           sec = bfd_get_section_by_name (abfd, ".liblist");
12201           if (sec != NULL)
12202             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12203           break;
12204
12205         case SHT_MIPS_EVENTS:
12206           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12207           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12208           BFD_ASSERT (name != NULL);
12209           if (CONST_STRNEQ (name, ".MIPS.events"))
12210             sec = bfd_get_section_by_name (abfd,
12211                                            name + sizeof ".MIPS.events" - 1);
12212           else
12213             {
12214               BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
12215               sec = bfd_get_section_by_name (abfd,
12216                                              (name
12217                                               + sizeof ".MIPS.post_rel" - 1));
12218             }
12219           BFD_ASSERT (sec != NULL);
12220           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12221           break;
12222
12223         }
12224     }
12225 }
12226 \f
12227 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12228    segments.  */
12229
12230 int
12231 _bfd_mips_elf_additional_program_headers (bfd *abfd,
12232                                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
12233 {
12234   asection *s;
12235   int ret = 0;
12236
12237   /* See if we need a PT_MIPS_REGINFO segment.  */
12238   s = bfd_get_section_by_name (abfd, ".reginfo");
12239   if (s && (s->flags & SEC_LOAD))
12240     ++ret;
12241
12242   /* See if we need a PT_MIPS_ABIFLAGS segment.  */
12243   if (bfd_get_section_by_name (abfd, ".MIPS.abiflags"))
12244     ++ret;
12245
12246   /* See if we need a PT_MIPS_OPTIONS segment.  */
12247   if (IRIX_COMPAT (abfd) == ict_irix6
12248       && bfd_get_section_by_name (abfd,
12249                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
12250     ++ret;
12251
12252   /* See if we need a PT_MIPS_RTPROC segment.  */
12253   if (IRIX_COMPAT (abfd) == ict_irix5
12254       && bfd_get_section_by_name (abfd, ".dynamic")
12255       && bfd_get_section_by_name (abfd, ".mdebug"))
12256     ++ret;
12257
12258   /* Allocate a PT_NULL header in dynamic objects.  See
12259      _bfd_mips_elf_modify_segment_map for details.  */
12260   if (!SGI_COMPAT (abfd)
12261       && bfd_get_section_by_name (abfd, ".dynamic"))
12262     ++ret;
12263
12264   return ret;
12265 }
12266
12267 /* Modify the segment map for an IRIX5 executable.  */
12268
12269 bfd_boolean
12270 _bfd_mips_elf_modify_segment_map (bfd *abfd,
12271                                   struct bfd_link_info *info)
12272 {
12273   asection *s;
12274   struct elf_segment_map *m, **pm;
12275   bfd_size_type amt;
12276
12277   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12278      segment.  */
12279   s = bfd_get_section_by_name (abfd, ".reginfo");
12280   if (s != NULL && (s->flags & SEC_LOAD) != 0)
12281     {
12282       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12283         if (m->p_type == PT_MIPS_REGINFO)
12284           break;
12285       if (m == NULL)
12286         {
12287           amt = sizeof *m;
12288           m = bfd_zalloc (abfd, amt);
12289           if (m == NULL)
12290             return FALSE;
12291
12292           m->p_type = PT_MIPS_REGINFO;
12293           m->count = 1;
12294           m->sections[0] = s;
12295
12296           /* We want to put it after the PHDR and INTERP segments.  */
12297           pm = &elf_seg_map (abfd);
12298           while (*pm != NULL
12299                  && ((*pm)->p_type == PT_PHDR
12300                      || (*pm)->p_type == PT_INTERP))
12301             pm = &(*pm)->next;
12302
12303           m->next = *pm;
12304           *pm = m;
12305         }
12306     }
12307
12308   /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12309      segment.  */
12310   s = bfd_get_section_by_name (abfd, ".MIPS.abiflags");
12311   if (s != NULL && (s->flags & SEC_LOAD) != 0)
12312     {
12313       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12314         if (m->p_type == PT_MIPS_ABIFLAGS)
12315           break;
12316       if (m == NULL)
12317         {
12318           amt = sizeof *m;
12319           m = bfd_zalloc (abfd, amt);
12320           if (m == NULL)
12321             return FALSE;
12322
12323           m->p_type = PT_MIPS_ABIFLAGS;
12324           m->count = 1;
12325           m->sections[0] = s;
12326
12327           /* We want to put it after the PHDR and INTERP segments.  */
12328           pm = &elf_seg_map (abfd);
12329           while (*pm != NULL
12330                  && ((*pm)->p_type == PT_PHDR
12331                      || (*pm)->p_type == PT_INTERP))
12332             pm = &(*pm)->next;
12333
12334           m->next = *pm;
12335           *pm = m;
12336         }
12337     }
12338
12339   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12340      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
12341      PT_MIPS_OPTIONS segment immediately following the program header
12342      table.  */
12343   if (NEWABI_P (abfd)
12344       /* On non-IRIX6 new abi, we'll have already created a segment
12345          for this section, so don't create another.  I'm not sure this
12346          is not also the case for IRIX 6, but I can't test it right
12347          now.  */
12348       && IRIX_COMPAT (abfd) == ict_irix6)
12349     {
12350       for (s = abfd->sections; s; s = s->next)
12351         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
12352           break;
12353
12354       if (s)
12355         {
12356           struct elf_segment_map *options_segment;
12357
12358           pm = &elf_seg_map (abfd);
12359           while (*pm != NULL
12360                  && ((*pm)->p_type == PT_PHDR
12361                      || (*pm)->p_type == PT_INTERP))
12362             pm = &(*pm)->next;
12363
12364           if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
12365             {
12366               amt = sizeof (struct elf_segment_map);
12367               options_segment = bfd_zalloc (abfd, amt);
12368               options_segment->next = *pm;
12369               options_segment->p_type = PT_MIPS_OPTIONS;
12370               options_segment->p_flags = PF_R;
12371               options_segment->p_flags_valid = TRUE;
12372               options_segment->count = 1;
12373               options_segment->sections[0] = s;
12374               *pm = options_segment;
12375             }
12376         }
12377     }
12378   else
12379     {
12380       if (IRIX_COMPAT (abfd) == ict_irix5)
12381         {
12382           /* If there are .dynamic and .mdebug sections, we make a room
12383              for the RTPROC header.  FIXME: Rewrite without section names.  */
12384           if (bfd_get_section_by_name (abfd, ".interp") == NULL
12385               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
12386               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
12387             {
12388               for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12389                 if (m->p_type == PT_MIPS_RTPROC)
12390                   break;
12391               if (m == NULL)
12392                 {
12393                   amt = sizeof *m;
12394                   m = bfd_zalloc (abfd, amt);
12395                   if (m == NULL)
12396                     return FALSE;
12397
12398                   m->p_type = PT_MIPS_RTPROC;
12399
12400                   s = bfd_get_section_by_name (abfd, ".rtproc");
12401                   if (s == NULL)
12402                     {
12403                       m->count = 0;
12404                       m->p_flags = 0;
12405                       m->p_flags_valid = 1;
12406                     }
12407                   else
12408                     {
12409                       m->count = 1;
12410                       m->sections[0] = s;
12411                     }
12412
12413                   /* We want to put it after the DYNAMIC segment.  */
12414                   pm = &elf_seg_map (abfd);
12415                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
12416                     pm = &(*pm)->next;
12417                   if (*pm != NULL)
12418                     pm = &(*pm)->next;
12419
12420                   m->next = *pm;
12421                   *pm = m;
12422                 }
12423             }
12424         }
12425       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12426          .dynstr, .dynsym, and .hash sections, and everything in
12427          between.  */
12428       for (pm = &elf_seg_map (abfd); *pm != NULL;
12429            pm = &(*pm)->next)
12430         if ((*pm)->p_type == PT_DYNAMIC)
12431           break;
12432       m = *pm;
12433       /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12434          glibc's dynamic linker has traditionally derived the number of
12435          tags from the p_filesz field, and sometimes allocates stack
12436          arrays of that size.  An overly-big PT_DYNAMIC segment can
12437          be actively harmful in such cases.  Making PT_DYNAMIC contain
12438          other sections can also make life hard for the prelinker,
12439          which might move one of the other sections to a different
12440          PT_LOAD segment.  */
12441       if (SGI_COMPAT (abfd)
12442           && m != NULL
12443           && m->count == 1
12444           && strcmp (m->sections[0]->name, ".dynamic") == 0)
12445         {
12446           static const char *sec_names[] =
12447           {
12448             ".dynamic", ".dynstr", ".dynsym", ".hash"
12449           };
12450           bfd_vma low, high;
12451           unsigned int i, c;
12452           struct elf_segment_map *n;
12453
12454           low = ~(bfd_vma) 0;
12455           high = 0;
12456           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
12457             {
12458               s = bfd_get_section_by_name (abfd, sec_names[i]);
12459               if (s != NULL && (s->flags & SEC_LOAD) != 0)
12460                 {
12461                   bfd_size_type sz;
12462
12463                   if (low > s->vma)
12464                     low = s->vma;
12465                   sz = s->size;
12466                   if (high < s->vma + sz)
12467                     high = s->vma + sz;
12468                 }
12469             }
12470
12471           c = 0;
12472           for (s = abfd->sections; s != NULL; s = s->next)
12473             if ((s->flags & SEC_LOAD) != 0
12474                 && s->vma >= low
12475                 && s->vma + s->size <= high)
12476               ++c;
12477
12478           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
12479           n = bfd_zalloc (abfd, amt);
12480           if (n == NULL)
12481             return FALSE;
12482           *n = *m;
12483           n->count = c;
12484
12485           i = 0;
12486           for (s = abfd->sections; s != NULL; s = s->next)
12487             {
12488               if ((s->flags & SEC_LOAD) != 0
12489                   && s->vma >= low
12490                   && s->vma + s->size <= high)
12491                 {
12492                   n->sections[i] = s;
12493                   ++i;
12494                 }
12495             }
12496
12497           *pm = n;
12498         }
12499     }
12500
12501   /* Allocate a spare program header in dynamic objects so that tools
12502      like the prelinker can add an extra PT_LOAD entry.
12503
12504      If the prelinker needs to make room for a new PT_LOAD entry, its
12505      standard procedure is to move the first (read-only) sections into
12506      the new (writable) segment.  However, the MIPS ABI requires
12507      .dynamic to be in a read-only segment, and the section will often
12508      start within sizeof (ElfNN_Phdr) bytes of the last program header.
12509
12510      Although the prelinker could in principle move .dynamic to a
12511      writable segment, it seems better to allocate a spare program
12512      header instead, and avoid the need to move any sections.
12513      There is a long tradition of allocating spare dynamic tags,
12514      so allocating a spare program header seems like a natural
12515      extension.
12516
12517      If INFO is NULL, we may be copying an already prelinked binary
12518      with objcopy or strip, so do not add this header.  */
12519   if (info != NULL
12520       && !SGI_COMPAT (abfd)
12521       && bfd_get_section_by_name (abfd, ".dynamic"))
12522     {
12523       for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
12524         if ((*pm)->p_type == PT_NULL)
12525           break;
12526       if (*pm == NULL)
12527         {
12528           m = bfd_zalloc (abfd, sizeof (*m));
12529           if (m == NULL)
12530             return FALSE;
12531
12532           m->p_type = PT_NULL;
12533           *pm = m;
12534         }
12535     }
12536
12537   return TRUE;
12538 }
12539 \f
12540 /* Return the section that should be marked against GC for a given
12541    relocation.  */
12542
12543 asection *
12544 _bfd_mips_elf_gc_mark_hook (asection *sec,
12545                             struct bfd_link_info *info,
12546                             Elf_Internal_Rela *rel,
12547                             struct elf_link_hash_entry *h,
12548                             Elf_Internal_Sym *sym)
12549 {
12550   /* ??? Do mips16 stub sections need to be handled special?  */
12551
12552   if (h != NULL)
12553     switch (ELF_R_TYPE (sec->owner, rel->r_info))
12554       {
12555       case R_MIPS_GNU_VTINHERIT:
12556       case R_MIPS_GNU_VTENTRY:
12557         return NULL;
12558       }
12559
12560   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
12561 }
12562
12563 /* Update the got entry reference counts for the section being removed.  */
12564
12565 bfd_boolean
12566 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
12567                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
12568                              asection *sec ATTRIBUTE_UNUSED,
12569                              const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
12570 {
12571 #if 0
12572   Elf_Internal_Shdr *symtab_hdr;
12573   struct elf_link_hash_entry **sym_hashes;
12574   bfd_signed_vma *local_got_refcounts;
12575   const Elf_Internal_Rela *rel, *relend;
12576   unsigned long r_symndx;
12577   struct elf_link_hash_entry *h;
12578
12579   if (bfd_link_relocatable (info))
12580     return TRUE;
12581
12582   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12583   sym_hashes = elf_sym_hashes (abfd);
12584   local_got_refcounts = elf_local_got_refcounts (abfd);
12585
12586   relend = relocs + sec->reloc_count;
12587   for (rel = relocs; rel < relend; rel++)
12588     switch (ELF_R_TYPE (abfd, rel->r_info))
12589       {
12590       case R_MIPS16_GOT16:
12591       case R_MIPS16_CALL16:
12592       case R_MIPS_GOT16:
12593       case R_MIPS_CALL16:
12594       case R_MIPS_CALL_HI16:
12595       case R_MIPS_CALL_LO16:
12596       case R_MIPS_GOT_HI16:
12597       case R_MIPS_GOT_LO16:
12598       case R_MIPS_GOT_DISP:
12599       case R_MIPS_GOT_PAGE:
12600       case R_MIPS_GOT_OFST:
12601       case R_MICROMIPS_GOT16:
12602       case R_MICROMIPS_CALL16:
12603       case R_MICROMIPS_CALL_HI16:
12604       case R_MICROMIPS_CALL_LO16:
12605       case R_MICROMIPS_GOT_HI16:
12606       case R_MICROMIPS_GOT_LO16:
12607       case R_MICROMIPS_GOT_DISP:
12608       case R_MICROMIPS_GOT_PAGE:
12609       case R_MICROMIPS_GOT_OFST:
12610         /* ??? It would seem that the existing MIPS code does no sort
12611            of reference counting or whatnot on its GOT and PLT entries,
12612            so it is not possible to garbage collect them at this time.  */
12613         break;
12614
12615       default:
12616         break;
12617       }
12618 #endif
12619
12620   return TRUE;
12621 }
12622
12623 /* Prevent .MIPS.abiflags from being discarded with --gc-sections.  */
12624
12625 bfd_boolean
12626 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12627                                       elf_gc_mark_hook_fn gc_mark_hook)
12628 {
12629   bfd *sub;
12630
12631   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
12632
12633   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12634     {
12635       asection *o;
12636
12637       if (! is_mips_elf (sub))
12638         continue;
12639
12640       for (o = sub->sections; o != NULL; o = o->next)
12641         if (!o->gc_mark
12642             && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
12643                  (bfd_get_section_name (sub, o)))
12644           {
12645             if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12646               return FALSE;
12647           }
12648     }
12649
12650   return TRUE;
12651 }
12652 \f
12653 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12654    hiding the old indirect symbol.  Process additional relocation
12655    information.  Also called for weakdefs, in which case we just let
12656    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
12657
12658 void
12659 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
12660                                     struct elf_link_hash_entry *dir,
12661                                     struct elf_link_hash_entry *ind)
12662 {
12663   struct mips_elf_link_hash_entry *dirmips, *indmips;
12664
12665   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
12666
12667   dirmips = (struct mips_elf_link_hash_entry *) dir;
12668   indmips = (struct mips_elf_link_hash_entry *) ind;
12669   /* Any absolute non-dynamic relocations against an indirect or weak
12670      definition will be against the target symbol.  */
12671   if (indmips->has_static_relocs)
12672     dirmips->has_static_relocs = TRUE;
12673
12674   if (ind->root.type != bfd_link_hash_indirect)
12675     return;
12676
12677   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
12678   if (indmips->readonly_reloc)
12679     dirmips->readonly_reloc = TRUE;
12680   if (indmips->no_fn_stub)
12681     dirmips->no_fn_stub = TRUE;
12682   if (indmips->fn_stub)
12683     {
12684       dirmips->fn_stub = indmips->fn_stub;
12685       indmips->fn_stub = NULL;
12686     }
12687   if (indmips->need_fn_stub)
12688     {
12689       dirmips->need_fn_stub = TRUE;
12690       indmips->need_fn_stub = FALSE;
12691     }
12692   if (indmips->call_stub)
12693     {
12694       dirmips->call_stub = indmips->call_stub;
12695       indmips->call_stub = NULL;
12696     }
12697   if (indmips->call_fp_stub)
12698     {
12699       dirmips->call_fp_stub = indmips->call_fp_stub;
12700       indmips->call_fp_stub = NULL;
12701     }
12702   if (indmips->global_got_area < dirmips->global_got_area)
12703     dirmips->global_got_area = indmips->global_got_area;
12704   if (indmips->global_got_area < GGA_NONE)
12705     indmips->global_got_area = GGA_NONE;
12706   if (indmips->has_nonpic_branches)
12707     dirmips->has_nonpic_branches = TRUE;
12708 }
12709 \f
12710 #define PDR_SIZE 32
12711
12712 bfd_boolean
12713 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
12714                             struct bfd_link_info *info)
12715 {
12716   asection *o;
12717   bfd_boolean ret = FALSE;
12718   unsigned char *tdata;
12719   size_t i, skip;
12720
12721   o = bfd_get_section_by_name (abfd, ".pdr");
12722   if (! o)
12723     return FALSE;
12724   if (o->size == 0)
12725     return FALSE;
12726   if (o->size % PDR_SIZE != 0)
12727     return FALSE;
12728   if (o->output_section != NULL
12729       && bfd_is_abs_section (o->output_section))
12730     return FALSE;
12731
12732   tdata = bfd_zmalloc (o->size / PDR_SIZE);
12733   if (! tdata)
12734     return FALSE;
12735
12736   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
12737                                             info->keep_memory);
12738   if (!cookie->rels)
12739     {
12740       free (tdata);
12741       return FALSE;
12742     }
12743
12744   cookie->rel = cookie->rels;
12745   cookie->relend = cookie->rels + o->reloc_count;
12746
12747   for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
12748     {
12749       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
12750         {
12751           tdata[i] = 1;
12752           skip ++;
12753         }
12754     }
12755
12756   if (skip != 0)
12757     {
12758       mips_elf_section_data (o)->u.tdata = tdata;
12759       if (o->rawsize == 0)
12760         o->rawsize = o->size;
12761       o->size -= skip * PDR_SIZE;
12762       ret = TRUE;
12763     }
12764   else
12765     free (tdata);
12766
12767   if (! info->keep_memory)
12768     free (cookie->rels);
12769
12770   return ret;
12771 }
12772
12773 bfd_boolean
12774 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
12775 {
12776   if (strcmp (sec->name, ".pdr") == 0)
12777     return TRUE;
12778   return FALSE;
12779 }
12780
12781 bfd_boolean
12782 _bfd_mips_elf_write_section (bfd *output_bfd,
12783                              struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
12784                              asection *sec, bfd_byte *contents)
12785 {
12786   bfd_byte *to, *from, *end;
12787   int i;
12788
12789   if (strcmp (sec->name, ".pdr") != 0)
12790     return FALSE;
12791
12792   if (mips_elf_section_data (sec)->u.tdata == NULL)
12793     return FALSE;
12794
12795   to = contents;
12796   end = contents + sec->size;
12797   for (from = contents, i = 0;
12798        from < end;
12799        from += PDR_SIZE, i++)
12800     {
12801       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
12802         continue;
12803       if (to != from)
12804         memcpy (to, from, PDR_SIZE);
12805       to += PDR_SIZE;
12806     }
12807   bfd_set_section_contents (output_bfd, sec->output_section, contents,
12808                             sec->output_offset, sec->size);
12809   return TRUE;
12810 }
12811 \f
12812 /* microMIPS code retains local labels for linker relaxation.  Omit them
12813    from output by default for clarity.  */
12814
12815 bfd_boolean
12816 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
12817 {
12818   return _bfd_elf_is_local_label_name (abfd, sym->name);
12819 }
12820
12821 /* MIPS ELF uses a special find_nearest_line routine in order the
12822    handle the ECOFF debugging information.  */
12823
12824 struct mips_elf_find_line
12825 {
12826   struct ecoff_debug_info d;
12827   struct ecoff_find_line i;
12828 };
12829
12830 bfd_boolean
12831 _bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols,
12832                                  asection *section, bfd_vma offset,
12833                                  const char **filename_ptr,
12834                                  const char **functionname_ptr,
12835                                  unsigned int *line_ptr,
12836                                  unsigned int *discriminator_ptr)
12837 {
12838   asection *msec;
12839
12840   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
12841                                      filename_ptr, functionname_ptr,
12842                                      line_ptr, discriminator_ptr,
12843                                      dwarf_debug_sections,
12844                                      ABI_64_P (abfd) ? 8 : 0,
12845                                      &elf_tdata (abfd)->dwarf2_find_line_info))
12846     return TRUE;
12847
12848   if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
12849                                      filename_ptr, functionname_ptr,
12850                                      line_ptr))
12851     return TRUE;
12852
12853   msec = bfd_get_section_by_name (abfd, ".mdebug");
12854   if (msec != NULL)
12855     {
12856       flagword origflags;
12857       struct mips_elf_find_line *fi;
12858       const struct ecoff_debug_swap * const swap =
12859         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
12860
12861       /* If we are called during a link, mips_elf_final_link may have
12862          cleared the SEC_HAS_CONTENTS field.  We force it back on here
12863          if appropriate (which it normally will be).  */
12864       origflags = msec->flags;
12865       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
12866         msec->flags |= SEC_HAS_CONTENTS;
12867
12868       fi = mips_elf_tdata (abfd)->find_line_info;
12869       if (fi == NULL)
12870         {
12871           bfd_size_type external_fdr_size;
12872           char *fraw_src;
12873           char *fraw_end;
12874           struct fdr *fdr_ptr;
12875           bfd_size_type amt = sizeof (struct mips_elf_find_line);
12876
12877           fi = bfd_zalloc (abfd, amt);
12878           if (fi == NULL)
12879             {
12880               msec->flags = origflags;
12881               return FALSE;
12882             }
12883
12884           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
12885             {
12886               msec->flags = origflags;
12887               return FALSE;
12888             }
12889
12890           /* Swap in the FDR information.  */
12891           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
12892           fi->d.fdr = bfd_alloc (abfd, amt);
12893           if (fi->d.fdr == NULL)
12894             {
12895               msec->flags = origflags;
12896               return FALSE;
12897             }
12898           external_fdr_size = swap->external_fdr_size;
12899           fdr_ptr = fi->d.fdr;
12900           fraw_src = (char *) fi->d.external_fdr;
12901           fraw_end = (fraw_src
12902                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
12903           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
12904             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
12905
12906           mips_elf_tdata (abfd)->find_line_info = fi;
12907
12908           /* Note that we don't bother to ever free this information.
12909              find_nearest_line is either called all the time, as in
12910              objdump -l, so the information should be saved, or it is
12911              rarely called, as in ld error messages, so the memory
12912              wasted is unimportant.  Still, it would probably be a
12913              good idea for free_cached_info to throw it away.  */
12914         }
12915
12916       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
12917                                   &fi->i, filename_ptr, functionname_ptr,
12918                                   line_ptr))
12919         {
12920           msec->flags = origflags;
12921           return TRUE;
12922         }
12923
12924       msec->flags = origflags;
12925     }
12926
12927   /* Fall back on the generic ELF find_nearest_line routine.  */
12928
12929   return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
12930                                      filename_ptr, functionname_ptr,
12931                                      line_ptr, discriminator_ptr);
12932 }
12933
12934 bfd_boolean
12935 _bfd_mips_elf_find_inliner_info (bfd *abfd,
12936                                  const char **filename_ptr,
12937                                  const char **functionname_ptr,
12938                                  unsigned int *line_ptr)
12939 {
12940   bfd_boolean found;
12941   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
12942                                          functionname_ptr, line_ptr,
12943                                          & elf_tdata (abfd)->dwarf2_find_line_info);
12944   return found;
12945 }
12946
12947 \f
12948 /* When are writing out the .options or .MIPS.options section,
12949    remember the bytes we are writing out, so that we can install the
12950    GP value in the section_processing routine.  */
12951
12952 bfd_boolean
12953 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
12954                                     const void *location,
12955                                     file_ptr offset, bfd_size_type count)
12956 {
12957   if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
12958     {
12959       bfd_byte *c;
12960
12961       if (elf_section_data (section) == NULL)
12962         {
12963           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
12964           section->used_by_bfd = bfd_zalloc (abfd, amt);
12965           if (elf_section_data (section) == NULL)
12966             return FALSE;
12967         }
12968       c = mips_elf_section_data (section)->u.tdata;
12969       if (c == NULL)
12970         {
12971           c = bfd_zalloc (abfd, section->size);
12972           if (c == NULL)
12973             return FALSE;
12974           mips_elf_section_data (section)->u.tdata = c;
12975         }
12976
12977       memcpy (c + offset, location, count);
12978     }
12979
12980   return _bfd_elf_set_section_contents (abfd, section, location, offset,
12981                                         count);
12982 }
12983
12984 /* This is almost identical to bfd_generic_get_... except that some
12985    MIPS relocations need to be handled specially.  Sigh.  */
12986
12987 bfd_byte *
12988 _bfd_elf_mips_get_relocated_section_contents
12989   (bfd *abfd,
12990    struct bfd_link_info *link_info,
12991    struct bfd_link_order *link_order,
12992    bfd_byte *data,
12993    bfd_boolean relocatable,
12994    asymbol **symbols)
12995 {
12996   /* Get enough memory to hold the stuff */
12997   bfd *input_bfd = link_order->u.indirect.section->owner;
12998   asection *input_section = link_order->u.indirect.section;
12999   bfd_size_type sz;
13000
13001   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13002   arelent **reloc_vector = NULL;
13003   long reloc_count;
13004
13005   if (reloc_size < 0)
13006     goto error_return;
13007
13008   reloc_vector = bfd_malloc (reloc_size);
13009   if (reloc_vector == NULL && reloc_size != 0)
13010     goto error_return;
13011
13012   /* read in the section */
13013   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
13014   if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
13015     goto error_return;
13016
13017   reloc_count = bfd_canonicalize_reloc (input_bfd,
13018                                         input_section,
13019                                         reloc_vector,
13020                                         symbols);
13021   if (reloc_count < 0)
13022     goto error_return;
13023
13024   if (reloc_count > 0)
13025     {
13026       arelent **parent;
13027       /* for mips */
13028       int gp_found;
13029       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
13030
13031       {
13032         struct bfd_hash_entry *h;
13033         struct bfd_link_hash_entry *lh;
13034         /* Skip all this stuff if we aren't mixing formats.  */
13035         if (abfd && input_bfd
13036             && abfd->xvec == input_bfd->xvec)
13037           lh = 0;
13038         else
13039           {
13040             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
13041             lh = (struct bfd_link_hash_entry *) h;
13042           }
13043       lookup:
13044         if (lh)
13045           {
13046             switch (lh->type)
13047               {
13048               case bfd_link_hash_undefined:
13049               case bfd_link_hash_undefweak:
13050               case bfd_link_hash_common:
13051                 gp_found = 0;
13052                 break;
13053               case bfd_link_hash_defined:
13054               case bfd_link_hash_defweak:
13055                 gp_found = 1;
13056                 gp = lh->u.def.value;
13057                 break;
13058               case bfd_link_hash_indirect:
13059               case bfd_link_hash_warning:
13060                 lh = lh->u.i.link;
13061                 /* @@FIXME  ignoring warning for now */
13062                 goto lookup;
13063               case bfd_link_hash_new:
13064               default:
13065                 abort ();
13066               }
13067           }
13068         else
13069           gp_found = 0;
13070       }
13071       /* end mips */
13072       for (parent = reloc_vector; *parent != NULL; parent++)
13073         {
13074           char *error_message = NULL;
13075           bfd_reloc_status_type r;
13076
13077           /* Specific to MIPS: Deal with relocation types that require
13078              knowing the gp of the output bfd.  */
13079           asymbol *sym = *(*parent)->sym_ptr_ptr;
13080
13081           /* If we've managed to find the gp and have a special
13082              function for the relocation then go ahead, else default
13083              to the generic handling.  */
13084           if (gp_found
13085               && (*parent)->howto->special_function
13086               == _bfd_mips_elf32_gprel16_reloc)
13087             r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
13088                                                input_section, relocatable,
13089                                                data, gp);
13090           else
13091             r = bfd_perform_relocation (input_bfd, *parent, data,
13092                                         input_section,
13093                                         relocatable ? abfd : NULL,
13094                                         &error_message);
13095
13096           if (relocatable)
13097             {
13098               asection *os = input_section->output_section;
13099
13100               /* A partial link, so keep the relocs */
13101               os->orelocation[os->reloc_count] = *parent;
13102               os->reloc_count++;
13103             }
13104
13105           if (r != bfd_reloc_ok)
13106             {
13107               switch (r)
13108                 {
13109                 case bfd_reloc_undefined:
13110                   (*link_info->callbacks->undefined_symbol)
13111                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13112                      input_bfd, input_section, (*parent)->address, TRUE);
13113                   break;
13114                 case bfd_reloc_dangerous:
13115                   BFD_ASSERT (error_message != NULL);
13116                   (*link_info->callbacks->reloc_dangerous)
13117                     (link_info, error_message,
13118                      input_bfd, input_section, (*parent)->address);
13119                   break;
13120                 case bfd_reloc_overflow:
13121                   (*link_info->callbacks->reloc_overflow)
13122                     (link_info, NULL,
13123                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13124                      (*parent)->howto->name, (*parent)->addend,
13125                      input_bfd, input_section, (*parent)->address);
13126                   break;
13127                 case bfd_reloc_outofrange:
13128                 default:
13129                   abort ();
13130                   break;
13131                 }
13132
13133             }
13134         }
13135     }
13136   if (reloc_vector != NULL)
13137     free (reloc_vector);
13138   return data;
13139
13140 error_return:
13141   if (reloc_vector != NULL)
13142     free (reloc_vector);
13143   return NULL;
13144 }
13145 \f
13146 static bfd_boolean
13147 mips_elf_relax_delete_bytes (bfd *abfd,
13148                              asection *sec, bfd_vma addr, int count)
13149 {
13150   Elf_Internal_Shdr *symtab_hdr;
13151   unsigned int sec_shndx;
13152   bfd_byte *contents;
13153   Elf_Internal_Rela *irel, *irelend;
13154   Elf_Internal_Sym *isym;
13155   Elf_Internal_Sym *isymend;
13156   struct elf_link_hash_entry **sym_hashes;
13157   struct elf_link_hash_entry **end_hashes;
13158   struct elf_link_hash_entry **start_hashes;
13159   unsigned int symcount;
13160
13161   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
13162   contents = elf_section_data (sec)->this_hdr.contents;
13163
13164   irel = elf_section_data (sec)->relocs;
13165   irelend = irel + sec->reloc_count;
13166
13167   /* Actually delete the bytes.  */
13168   memmove (contents + addr, contents + addr + count,
13169            (size_t) (sec->size - addr - count));
13170   sec->size -= count;
13171
13172   /* Adjust all the relocs.  */
13173   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
13174     {
13175       /* Get the new reloc address.  */
13176       if (irel->r_offset > addr)
13177         irel->r_offset -= count;
13178     }
13179
13180   BFD_ASSERT (addr % 2 == 0);
13181   BFD_ASSERT (count % 2 == 0);
13182
13183   /* Adjust the local symbols defined in this section.  */
13184   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13185   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
13186   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
13187     if (isym->st_shndx == sec_shndx && isym->st_value > addr)
13188       isym->st_value -= count;
13189
13190   /* Now adjust the global symbols defined in this section.  */
13191   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
13192               - symtab_hdr->sh_info);
13193   sym_hashes = start_hashes = elf_sym_hashes (abfd);
13194   end_hashes = sym_hashes + symcount;
13195
13196   for (; sym_hashes < end_hashes; sym_hashes++)
13197     {
13198       struct elf_link_hash_entry *sym_hash = *sym_hashes;
13199
13200       if ((sym_hash->root.type == bfd_link_hash_defined
13201            || sym_hash->root.type == bfd_link_hash_defweak)
13202           && sym_hash->root.u.def.section == sec)
13203         {
13204           bfd_vma value = sym_hash->root.u.def.value;
13205
13206           if (ELF_ST_IS_MICROMIPS (sym_hash->other))
13207             value &= MINUS_TWO;
13208           if (value > addr)
13209             sym_hash->root.u.def.value -= count;
13210         }
13211     }
13212
13213   return TRUE;
13214 }
13215
13216
13217 /* Opcodes needed for microMIPS relaxation as found in
13218    opcodes/micromips-opc.c.  */
13219
13220 struct opcode_descriptor {
13221   unsigned long match;
13222   unsigned long mask;
13223 };
13224
13225 /* The $ra register aka $31.  */
13226
13227 #define RA 31
13228
13229 /* 32-bit instruction format register fields.  */
13230
13231 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13232 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13233
13234 /* Check if a 5-bit register index can be abbreviated to 3 bits.  */
13235
13236 #define OP16_VALID_REG(r) \
13237   ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13238
13239
13240 /* 32-bit and 16-bit branches.  */
13241
13242 static const struct opcode_descriptor b_insns_32[] = {
13243   { /* "b",     "p",            */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13244   { /* "b",     "p",            */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13245   { 0, 0 }  /* End marker for find_match().  */
13246 };
13247
13248 static const struct opcode_descriptor bc_insn_32 =
13249   { /* "bc(1|2)(ft)", "N,p",    */ 0x42800000, 0xfec30000 };
13250
13251 static const struct opcode_descriptor bz_insn_32 =
13252   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 };
13253
13254 static const struct opcode_descriptor bzal_insn_32 =
13255   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 };
13256
13257 static const struct opcode_descriptor beq_insn_32 =
13258   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 };
13259
13260 static const struct opcode_descriptor b_insn_16 =
13261   { /* "b",     "mD",           */ 0xcc00,     0xfc00 };
13262
13263 static const struct opcode_descriptor bz_insn_16 =
13264   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 };
13265
13266
13267 /* 32-bit and 16-bit branch EQ and NE zero.  */
13268
13269 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13270    eq and second the ne.  This convention is used when replacing a
13271    32-bit BEQ/BNE with the 16-bit version.  */
13272
13273 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13274
13275 static const struct opcode_descriptor bz_rs_insns_32[] = {
13276   { /* "beqz",  "s,p",          */ 0x94000000, 0xffe00000 },
13277   { /* "bnez",  "s,p",          */ 0xb4000000, 0xffe00000 },
13278   { 0, 0 }  /* End marker for find_match().  */
13279 };
13280
13281 static const struct opcode_descriptor bz_rt_insns_32[] = {
13282   { /* "beqz",  "t,p",          */ 0x94000000, 0xfc01f000 },
13283   { /* "bnez",  "t,p",          */ 0xb4000000, 0xfc01f000 },
13284   { 0, 0 }  /* End marker for find_match().  */
13285 };
13286
13287 static const struct opcode_descriptor bzc_insns_32[] = {
13288   { /* "beqzc", "s,p",          */ 0x40e00000, 0xffe00000 },
13289   { /* "bnezc", "s,p",          */ 0x40a00000, 0xffe00000 },
13290   { 0, 0 }  /* End marker for find_match().  */
13291 };
13292
13293 static const struct opcode_descriptor bz_insns_16[] = {
13294   { /* "beqz",  "md,mE",        */ 0x8c00,     0xfc00 },
13295   { /* "bnez",  "md,mE",        */ 0xac00,     0xfc00 },
13296   { 0, 0 }  /* End marker for find_match().  */
13297 };
13298
13299 /* Switch between a 5-bit register index and its 3-bit shorthand.  */
13300
13301 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2)
13302 #define BZ16_REG_FIELD(r) (((r) & 7) << 7)
13303
13304
13305 /* 32-bit instructions with a delay slot.  */
13306
13307 static const struct opcode_descriptor jal_insn_32_bd16 =
13308   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 };
13309
13310 static const struct opcode_descriptor jal_insn_32_bd32 =
13311   { /* "jal",   "a",            */ 0xf4000000, 0xfc000000 };
13312
13313 static const struct opcode_descriptor jal_x_insn_32_bd32 =
13314   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 };
13315
13316 static const struct opcode_descriptor j_insn_32 =
13317   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 };
13318
13319 static const struct opcode_descriptor jalr_insn_32 =
13320   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff };
13321
13322 /* This table can be compacted, because no opcode replacement is made.  */
13323
13324 static const struct opcode_descriptor ds_insns_32_bd16[] = {
13325   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 },
13326
13327   { /* "jalrs[.hb]", "t,s",     */ 0x00004f3c, 0xfc00efff },
13328   { /* "b(ge|lt)zals", "s,p",   */ 0x42200000, 0xffa00000 },
13329
13330   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 },
13331   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 },
13332   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 },
13333   { 0, 0 }  /* End marker for find_match().  */
13334 };
13335
13336 /* This table can be compacted, because no opcode replacement is made.  */
13337
13338 static const struct opcode_descriptor ds_insns_32_bd32[] = {
13339   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 },
13340
13341   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff },
13342   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 },
13343   { 0, 0 }  /* End marker for find_match().  */
13344 };
13345
13346
13347 /* 16-bit instructions with a delay slot.  */
13348
13349 static const struct opcode_descriptor jalr_insn_16_bd16 =
13350   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 };
13351
13352 static const struct opcode_descriptor jalr_insn_16_bd32 =
13353   { /* "jalr",  "my,mj",        */ 0x45c0,     0xffe0 };
13354
13355 static const struct opcode_descriptor jr_insn_16 =
13356   { /* "jr",    "mj",           */ 0x4580,     0xffe0 };
13357
13358 #define JR16_REG(opcode) ((opcode) & 0x1f)
13359
13360 /* This table can be compacted, because no opcode replacement is made.  */
13361
13362 static const struct opcode_descriptor ds_insns_16_bd16[] = {
13363   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 },
13364
13365   { /* "b",     "mD",           */ 0xcc00,     0xfc00 },
13366   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 },
13367   { /* "jr",    "mj",           */ 0x4580,     0xffe0 },
13368   { 0, 0 }  /* End marker for find_match().  */
13369 };
13370
13371
13372 /* LUI instruction.  */
13373
13374 static const struct opcode_descriptor lui_insn =
13375  { /* "lui",    "s,u",          */ 0x41a00000, 0xffe00000 };
13376
13377
13378 /* ADDIU instruction.  */
13379
13380 static const struct opcode_descriptor addiu_insn =
13381   { /* "addiu", "t,r,j",        */ 0x30000000, 0xfc000000 };
13382
13383 static const struct opcode_descriptor addiupc_insn =
13384   { /* "addiu", "mb,$pc,mQ",    */ 0x78000000, 0xfc000000 };
13385
13386 #define ADDIUPC_REG_FIELD(r) \
13387   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13388
13389
13390 /* Relaxable instructions in a JAL delay slot: MOVE.  */
13391
13392 /* The 16-bit move has rd in 9:5 and rs in 4:0.  The 32-bit moves
13393    (ADDU, OR) have rd in 15:11 and rs in 10:16.  */
13394 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13395 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13396
13397 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13398 #define MOVE16_RS_FIELD(r) (((r) & 0x1f)     )
13399
13400 static const struct opcode_descriptor move_insns_32[] = {
13401   { /* "move",  "d,s",          */ 0x00000290, 0xffe007ff }, /* or   d,s,$0 */
13402   { /* "move",  "d,s",          */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13403   { 0, 0 }  /* End marker for find_match().  */
13404 };
13405
13406 static const struct opcode_descriptor move_insn_16 =
13407   { /* "move",  "mp,mj",        */ 0x0c00,     0xfc00 };
13408
13409
13410 /* NOP instructions.  */
13411
13412 static const struct opcode_descriptor nop_insn_32 =
13413   { /* "nop",   "",             */ 0x00000000, 0xffffffff };
13414
13415 static const struct opcode_descriptor nop_insn_16 =
13416   { /* "nop",   "",             */ 0x0c00,     0xffff };
13417
13418
13419 /* Instruction match support.  */
13420
13421 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13422
13423 static int
13424 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
13425 {
13426   unsigned long indx;
13427
13428   for (indx = 0; insn[indx].mask != 0; indx++)
13429     if (MATCH (opcode, insn[indx]))
13430       return indx;
13431
13432   return -1;
13433 }
13434
13435
13436 /* Branch and delay slot decoding support.  */
13437
13438 /* If PTR points to what *might* be a 16-bit branch or jump, then
13439    return the minimum length of its delay slot, otherwise return 0.
13440    Non-zero results are not definitive as we might be checking against
13441    the second half of another instruction.  */
13442
13443 static int
13444 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
13445 {
13446   unsigned long opcode;
13447   int bdsize;
13448
13449   opcode = bfd_get_16 (abfd, ptr);
13450   if (MATCH (opcode, jalr_insn_16_bd32) != 0)
13451     /* 16-bit branch/jump with a 32-bit delay slot.  */
13452     bdsize = 4;
13453   else if (MATCH (opcode, jalr_insn_16_bd16) != 0
13454            || find_match (opcode, ds_insns_16_bd16) >= 0)
13455     /* 16-bit branch/jump with a 16-bit delay slot.  */
13456     bdsize = 2;
13457   else
13458     /* No delay slot.  */
13459     bdsize = 0;
13460
13461   return bdsize;
13462 }
13463
13464 /* If PTR points to what *might* be a 32-bit branch or jump, then
13465    return the minimum length of its delay slot, otherwise return 0.
13466    Non-zero results are not definitive as we might be checking against
13467    the second half of another instruction.  */
13468
13469 static int
13470 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
13471 {
13472   unsigned long opcode;
13473   int bdsize;
13474
13475   opcode = bfd_get_micromips_32 (abfd, ptr);
13476   if (find_match (opcode, ds_insns_32_bd32) >= 0)
13477     /* 32-bit branch/jump with a 32-bit delay slot.  */
13478     bdsize = 4;
13479   else if (find_match (opcode, ds_insns_32_bd16) >= 0)
13480     /* 32-bit branch/jump with a 16-bit delay slot.  */
13481     bdsize = 2;
13482   else
13483     /* No delay slot.  */
13484     bdsize = 0;
13485
13486   return bdsize;
13487 }
13488
13489 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13490    that doesn't fiddle with REG, then return TRUE, otherwise FALSE.  */
13491
13492 static bfd_boolean
13493 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13494 {
13495   unsigned long opcode;
13496
13497   opcode = bfd_get_16 (abfd, ptr);
13498   if (MATCH (opcode, b_insn_16)
13499                                                 /* B16  */
13500       || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
13501                                                 /* JR16  */
13502       || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
13503                                                 /* BEQZ16, BNEZ16  */
13504       || (MATCH (opcode, jalr_insn_16_bd32)
13505                                                 /* JALR16  */
13506           && reg != JR16_REG (opcode) && reg != RA))
13507     return TRUE;
13508
13509   return FALSE;
13510 }
13511
13512 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13513    then return TRUE, otherwise FALSE.  */
13514
13515 static bfd_boolean
13516 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13517 {
13518   unsigned long opcode;
13519
13520   opcode = bfd_get_micromips_32 (abfd, ptr);
13521   if (MATCH (opcode, j_insn_32)
13522                                                 /* J  */
13523       || MATCH (opcode, bc_insn_32)
13524                                                 /* BC1F, BC1T, BC2F, BC2T  */
13525       || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
13526                                                 /* JAL, JALX  */
13527       || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
13528                                                 /* BGEZ, BGTZ, BLEZ, BLTZ  */
13529       || (MATCH (opcode, bzal_insn_32)
13530                                                 /* BGEZAL, BLTZAL  */
13531           && reg != OP32_SREG (opcode) && reg != RA)
13532       || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
13533                                                 /* JALR, JALR.HB, BEQ, BNE  */
13534           && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
13535     return TRUE;
13536
13537   return FALSE;
13538 }
13539
13540 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13541    IRELEND) at OFFSET indicate that there must be a compact branch there,
13542    then return TRUE, otherwise FALSE.  */
13543
13544 static bfd_boolean
13545 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
13546                      const Elf_Internal_Rela *internal_relocs,
13547                      const Elf_Internal_Rela *irelend)
13548 {
13549   const Elf_Internal_Rela *irel;
13550   unsigned long opcode;
13551
13552   opcode = bfd_get_micromips_32 (abfd, ptr);
13553   if (find_match (opcode, bzc_insns_32) < 0)
13554     return FALSE;
13555
13556   for (irel = internal_relocs; irel < irelend; irel++)
13557     if (irel->r_offset == offset
13558         && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
13559       return TRUE;
13560
13561   return FALSE;
13562 }
13563
13564 /* Bitsize checking.  */
13565 #define IS_BITSIZE(val, N)                                              \
13566   (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1)))               \
13567     - (1ULL << ((N) - 1))) == (val))
13568
13569 \f
13570 bfd_boolean
13571 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
13572                              struct bfd_link_info *link_info,
13573                              bfd_boolean *again)
13574 {
13575   bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32;
13576   Elf_Internal_Shdr *symtab_hdr;
13577   Elf_Internal_Rela *internal_relocs;
13578   Elf_Internal_Rela *irel, *irelend;
13579   bfd_byte *contents = NULL;
13580   Elf_Internal_Sym *isymbuf = NULL;
13581
13582   /* Assume nothing changes.  */
13583   *again = FALSE;
13584
13585   /* We don't have to do anything for a relocatable link, if
13586      this section does not have relocs, or if this is not a
13587      code section.  */
13588
13589   if (bfd_link_relocatable (link_info)
13590       || (sec->flags & SEC_RELOC) == 0
13591       || sec->reloc_count == 0
13592       || (sec->flags & SEC_CODE) == 0)
13593     return TRUE;
13594
13595   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13596
13597   /* Get a copy of the native relocations.  */
13598   internal_relocs = (_bfd_elf_link_read_relocs
13599                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
13600                       link_info->keep_memory));
13601   if (internal_relocs == NULL)
13602     goto error_return;
13603
13604   /* Walk through them looking for relaxing opportunities.  */
13605   irelend = internal_relocs + sec->reloc_count;
13606   for (irel = internal_relocs; irel < irelend; irel++)
13607     {
13608       unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
13609       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
13610       bfd_boolean target_is_micromips_code_p;
13611       unsigned long opcode;
13612       bfd_vma symval;
13613       bfd_vma pcrval;
13614       bfd_byte *ptr;
13615       int fndopc;
13616
13617       /* The number of bytes to delete for relaxation and from where
13618          to delete these bytes starting at irel->r_offset.  */
13619       int delcnt = 0;
13620       int deloff = 0;
13621
13622       /* If this isn't something that can be relaxed, then ignore
13623          this reloc.  */
13624       if (r_type != R_MICROMIPS_HI16
13625           && r_type != R_MICROMIPS_PC16_S1
13626           && r_type != R_MICROMIPS_26_S1)
13627         continue;
13628
13629       /* Get the section contents if we haven't done so already.  */
13630       if (contents == NULL)
13631         {
13632           /* Get cached copy if it exists.  */
13633           if (elf_section_data (sec)->this_hdr.contents != NULL)
13634             contents = elf_section_data (sec)->this_hdr.contents;
13635           /* Go get them off disk.  */
13636           else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
13637             goto error_return;
13638         }
13639       ptr = contents + irel->r_offset;
13640
13641       /* Read this BFD's local symbols if we haven't done so already.  */
13642       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
13643         {
13644           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
13645           if (isymbuf == NULL)
13646             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
13647                                             symtab_hdr->sh_info, 0,
13648                                             NULL, NULL, NULL);
13649           if (isymbuf == NULL)
13650             goto error_return;
13651         }
13652
13653       /* Get the value of the symbol referred to by the reloc.  */
13654       if (r_symndx < symtab_hdr->sh_info)
13655         {
13656           /* A local symbol.  */
13657           Elf_Internal_Sym *isym;
13658           asection *sym_sec;
13659
13660           isym = isymbuf + r_symndx;
13661           if (isym->st_shndx == SHN_UNDEF)
13662             sym_sec = bfd_und_section_ptr;
13663           else if (isym->st_shndx == SHN_ABS)
13664             sym_sec = bfd_abs_section_ptr;
13665           else if (isym->st_shndx == SHN_COMMON)
13666             sym_sec = bfd_com_section_ptr;
13667           else
13668             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
13669           symval = (isym->st_value
13670                     + sym_sec->output_section->vma
13671                     + sym_sec->output_offset);
13672           target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
13673         }
13674       else
13675         {
13676           unsigned long indx;
13677           struct elf_link_hash_entry *h;
13678
13679           /* An external symbol.  */
13680           indx = r_symndx - symtab_hdr->sh_info;
13681           h = elf_sym_hashes (abfd)[indx];
13682           BFD_ASSERT (h != NULL);
13683
13684           if (h->root.type != bfd_link_hash_defined
13685               && h->root.type != bfd_link_hash_defweak)
13686             /* This appears to be a reference to an undefined
13687                symbol.  Just ignore it -- it will be caught by the
13688                regular reloc processing.  */
13689             continue;
13690
13691           symval = (h->root.u.def.value
13692                     + h->root.u.def.section->output_section->vma
13693                     + h->root.u.def.section->output_offset);
13694           target_is_micromips_code_p = (!h->needs_plt
13695                                         && ELF_ST_IS_MICROMIPS (h->other));
13696         }
13697
13698
13699       /* For simplicity of coding, we are going to modify the
13700          section contents, the section relocs, and the BFD symbol
13701          table.  We must tell the rest of the code not to free up this
13702          information.  It would be possible to instead create a table
13703          of changes which have to be made, as is done in coff-mips.c;
13704          that would be more work, but would require less memory when
13705          the linker is run.  */
13706
13707       /* Only 32-bit instructions relaxed.  */
13708       if (irel->r_offset + 4 > sec->size)
13709         continue;
13710
13711       opcode = bfd_get_micromips_32 (abfd, ptr);
13712
13713       /* This is the pc-relative distance from the instruction the
13714          relocation is applied to, to the symbol referred.  */
13715       pcrval = (symval
13716                 - (sec->output_section->vma + sec->output_offset)
13717                 - irel->r_offset);
13718
13719       /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13720          of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13721          R_MICROMIPS_PC23_S2.  The R_MICROMIPS_PC23_S2 condition is
13722
13723            (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13724
13725          where pcrval has first to be adjusted to apply against the LO16
13726          location (we make the adjustment later on, when we have figured
13727          out the offset).  */
13728       if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
13729         {
13730           bfd_boolean bzc = FALSE;
13731           unsigned long nextopc;
13732           unsigned long reg;
13733           bfd_vma offset;
13734
13735           /* Give up if the previous reloc was a HI16 against this symbol
13736              too.  */
13737           if (irel > internal_relocs
13738               && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
13739               && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
13740             continue;
13741
13742           /* Or if the next reloc is not a LO16 against this symbol.  */
13743           if (irel + 1 >= irelend
13744               || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
13745               || ELF32_R_SYM (irel[1].r_info) != r_symndx)
13746             continue;
13747
13748           /* Or if the second next reloc is a LO16 against this symbol too.  */
13749           if (irel + 2 >= irelend
13750               && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
13751               && ELF32_R_SYM (irel[2].r_info) == r_symndx)
13752             continue;
13753
13754           /* See if the LUI instruction *might* be in a branch delay slot.
13755              We check whether what looks like a 16-bit branch or jump is
13756              actually an immediate argument to a compact branch, and let
13757              it through if so.  */
13758           if (irel->r_offset >= 2
13759               && check_br16_dslot (abfd, ptr - 2)
13760               && !(irel->r_offset >= 4
13761                    && (bzc = check_relocated_bzc (abfd,
13762                                                   ptr - 4, irel->r_offset - 4,
13763                                                   internal_relocs, irelend))))
13764             continue;
13765           if (irel->r_offset >= 4
13766               && !bzc
13767               && check_br32_dslot (abfd, ptr - 4))
13768             continue;
13769
13770           reg = OP32_SREG (opcode);
13771
13772           /* We only relax adjacent instructions or ones separated with
13773              a branch or jump that has a delay slot.  The branch or jump
13774              must not fiddle with the register used to hold the address.
13775              Subtract 4 for the LUI itself.  */
13776           offset = irel[1].r_offset - irel[0].r_offset;
13777           switch (offset - 4)
13778             {
13779             case 0:
13780               break;
13781             case 2:
13782               if (check_br16 (abfd, ptr + 4, reg))
13783                 break;
13784               continue;
13785             case 4:
13786               if (check_br32 (abfd, ptr + 4, reg))
13787                 break;
13788               continue;
13789             default:
13790               continue;
13791             }
13792
13793           nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
13794
13795           /* Give up unless the same register is used with both
13796              relocations.  */
13797           if (OP32_SREG (nextopc) != reg)
13798             continue;
13799
13800           /* Now adjust pcrval, subtracting the offset to the LO16 reloc
13801              and rounding up to take masking of the two LSBs into account.  */
13802           pcrval = ((pcrval - offset + 3) | 3) ^ 3;
13803
13804           /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16.  */
13805           if (IS_BITSIZE (symval, 16))
13806             {
13807               /* Fix the relocation's type.  */
13808               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
13809
13810               /* Instructions using R_MICROMIPS_LO16 have the base or
13811                  source register in bits 20:16.  This register becomes $0
13812                  (zero) as the result of the R_MICROMIPS_HI16 being 0.  */
13813               nextopc &= ~0x001f0000;
13814               bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
13815                           contents + irel[1].r_offset);
13816             }
13817
13818           /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
13819              We add 4 to take LUI deletion into account while checking
13820              the PC-relative distance.  */
13821           else if (symval % 4 == 0
13822                    && IS_BITSIZE (pcrval + 4, 25)
13823                    && MATCH (nextopc, addiu_insn)
13824                    && OP32_TREG (nextopc) == OP32_SREG (nextopc)
13825                    && OP16_VALID_REG (OP32_TREG (nextopc)))
13826             {
13827               /* Fix the relocation's type.  */
13828               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
13829
13830               /* Replace ADDIU with the ADDIUPC version.  */
13831               nextopc = (addiupc_insn.match
13832                          | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
13833
13834               bfd_put_micromips_32 (abfd, nextopc,
13835                                     contents + irel[1].r_offset);
13836             }
13837
13838           /* Can't do anything, give up, sigh...  */
13839           else
13840             continue;
13841
13842           /* Fix the relocation's type.  */
13843           irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
13844
13845           /* Delete the LUI instruction: 4 bytes at irel->r_offset.  */
13846           delcnt = 4;
13847           deloff = 0;
13848         }
13849
13850       /* Compact branch relaxation -- due to the multitude of macros
13851          employed by the compiler/assembler, compact branches are not
13852          always generated.  Obviously, this can/will be fixed elsewhere,
13853          but there is no drawback in double checking it here.  */
13854       else if (r_type == R_MICROMIPS_PC16_S1
13855                && irel->r_offset + 5 < sec->size
13856                && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13857                    || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
13858                && ((!insn32
13859                     && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4),
13860                                         nop_insn_16) ? 2 : 0))
13861                    || (irel->r_offset + 7 < sec->size
13862                        && (delcnt = MATCH (bfd_get_micromips_32 (abfd,
13863                                                                  ptr + 4),
13864                                            nop_insn_32) ? 4 : 0))))
13865         {
13866           unsigned long reg;
13867
13868           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13869
13870           /* Replace BEQZ/BNEZ with the compact version.  */
13871           opcode = (bzc_insns_32[fndopc].match
13872                     | BZC32_REG_FIELD (reg)
13873                     | (opcode & 0xffff));               /* Addend value.  */
13874
13875           bfd_put_micromips_32 (abfd, opcode, ptr);
13876
13877           /* Delete the delay slot NOP: two or four bytes from
13878              irel->offset + 4; delcnt has already been set above.  */
13879           deloff = 4;
13880         }
13881
13882       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1.  We need
13883          to check the distance from the next instruction, so subtract 2.  */
13884       else if (!insn32
13885                && r_type == R_MICROMIPS_PC16_S1
13886                && IS_BITSIZE (pcrval - 2, 11)
13887                && find_match (opcode, b_insns_32) >= 0)
13888         {
13889           /* Fix the relocation's type.  */
13890           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
13891
13892           /* Replace the 32-bit opcode with a 16-bit opcode.  */
13893           bfd_put_16 (abfd,
13894                       (b_insn_16.match
13895                        | (opcode & 0x3ff)),             /* Addend value.  */
13896                       ptr);
13897
13898           /* Delete 2 bytes from irel->r_offset + 2.  */
13899           delcnt = 2;
13900           deloff = 2;
13901         }
13902
13903       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1.  We need
13904          to check the distance from the next instruction, so subtract 2.  */
13905       else if (!insn32
13906                && r_type == R_MICROMIPS_PC16_S1
13907                && IS_BITSIZE (pcrval - 2, 8)
13908                && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13909                     && OP16_VALID_REG (OP32_SREG (opcode)))
13910                    || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
13911                        && OP16_VALID_REG (OP32_TREG (opcode)))))
13912         {
13913           unsigned long reg;
13914
13915           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13916
13917           /* Fix the relocation's type.  */
13918           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
13919
13920           /* Replace the 32-bit opcode with a 16-bit opcode.  */
13921           bfd_put_16 (abfd,
13922                       (bz_insns_16[fndopc].match
13923                        | BZ16_REG_FIELD (reg)
13924                        | (opcode & 0x7f)),              /* Addend value.  */
13925                       ptr);
13926
13927           /* Delete 2 bytes from irel->r_offset + 2.  */
13928           delcnt = 2;
13929           deloff = 2;
13930         }
13931
13932       /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets.  */
13933       else if (!insn32
13934                && r_type == R_MICROMIPS_26_S1
13935                && target_is_micromips_code_p
13936                && irel->r_offset + 7 < sec->size
13937                && MATCH (opcode, jal_insn_32_bd32))
13938         {
13939           unsigned long n32opc;
13940           bfd_boolean relaxed = FALSE;
13941
13942           n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
13943
13944           if (MATCH (n32opc, nop_insn_32))
13945             {
13946               /* Replace delay slot 32-bit NOP with a 16-bit NOP.  */
13947               bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
13948
13949               relaxed = TRUE;
13950             }
13951           else if (find_match (n32opc, move_insns_32) >= 0)
13952             {
13953               /* Replace delay slot 32-bit MOVE with 16-bit MOVE.  */
13954               bfd_put_16 (abfd,
13955                           (move_insn_16.match
13956                            | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
13957                            | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
13958                           ptr + 4);
13959
13960               relaxed = TRUE;
13961             }
13962           /* Other 32-bit instructions relaxable to 16-bit
13963              instructions will be handled here later.  */
13964
13965           if (relaxed)
13966             {
13967               /* JAL with 32-bit delay slot that is changed to a JALS
13968                  with 16-bit delay slot.  */
13969               bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
13970
13971               /* Delete 2 bytes from irel->r_offset + 6.  */
13972               delcnt = 2;
13973               deloff = 6;
13974             }
13975         }
13976
13977       if (delcnt != 0)
13978         {
13979           /* Note that we've changed the relocs, section contents, etc.  */
13980           elf_section_data (sec)->relocs = internal_relocs;
13981           elf_section_data (sec)->this_hdr.contents = contents;
13982           symtab_hdr->contents = (unsigned char *) isymbuf;
13983
13984           /* Delete bytes depending on the delcnt and deloff.  */
13985           if (!mips_elf_relax_delete_bytes (abfd, sec,
13986                                             irel->r_offset + deloff, delcnt))
13987             goto error_return;
13988
13989           /* That will change things, so we should relax again.
13990              Note that this is not required, and it may be slow.  */
13991           *again = TRUE;
13992         }
13993     }
13994
13995   if (isymbuf != NULL
13996       && symtab_hdr->contents != (unsigned char *) isymbuf)
13997     {
13998       if (! link_info->keep_memory)
13999         free (isymbuf);
14000       else
14001         {
14002           /* Cache the symbols for elf_link_input_bfd.  */
14003           symtab_hdr->contents = (unsigned char *) isymbuf;
14004         }
14005     }
14006
14007   if (contents != NULL
14008       && elf_section_data (sec)->this_hdr.contents != contents)
14009     {
14010       if (! link_info->keep_memory)
14011         free (contents);
14012       else
14013         {
14014           /* Cache the section contents for elf_link_input_bfd.  */
14015           elf_section_data (sec)->this_hdr.contents = contents;
14016         }
14017     }
14018
14019   if (internal_relocs != NULL
14020       && elf_section_data (sec)->relocs != internal_relocs)
14021     free (internal_relocs);
14022
14023   return TRUE;
14024
14025  error_return:
14026   if (isymbuf != NULL
14027       && symtab_hdr->contents != (unsigned char *) isymbuf)
14028     free (isymbuf);
14029   if (contents != NULL
14030       && elf_section_data (sec)->this_hdr.contents != contents)
14031     free (contents);
14032   if (internal_relocs != NULL
14033       && elf_section_data (sec)->relocs != internal_relocs)
14034     free (internal_relocs);
14035
14036   return FALSE;
14037 }
14038 \f
14039 /* Create a MIPS ELF linker hash table.  */
14040
14041 struct bfd_link_hash_table *
14042 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
14043 {
14044   struct mips_elf_link_hash_table *ret;
14045   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
14046
14047   ret = bfd_zmalloc (amt);
14048   if (ret == NULL)
14049     return NULL;
14050
14051   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
14052                                       mips_elf_link_hash_newfunc,
14053                                       sizeof (struct mips_elf_link_hash_entry),
14054                                       MIPS_ELF_DATA))
14055     {
14056       free (ret);
14057       return NULL;
14058     }
14059   ret->root.init_plt_refcount.plist = NULL;
14060   ret->root.init_plt_offset.plist = NULL;
14061
14062   return &ret->root.root;
14063 }
14064
14065 /* Likewise, but indicate that the target is VxWorks.  */
14066
14067 struct bfd_link_hash_table *
14068 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
14069 {
14070   struct bfd_link_hash_table *ret;
14071
14072   ret = _bfd_mips_elf_link_hash_table_create (abfd);
14073   if (ret)
14074     {
14075       struct mips_elf_link_hash_table *htab;
14076
14077       htab = (struct mips_elf_link_hash_table *) ret;
14078       htab->use_plts_and_copy_relocs = TRUE;
14079       htab->is_vxworks = TRUE;
14080     }
14081   return ret;
14082 }
14083
14084 /* A function that the linker calls if we are allowed to use PLTs
14085    and copy relocs.  */
14086
14087 void
14088 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
14089 {
14090   mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
14091 }
14092
14093 /* A function that the linker calls to select between all or only
14094    32-bit microMIPS instructions.  */
14095
14096 void
14097 _bfd_mips_elf_insn32 (struct bfd_link_info *info, bfd_boolean on)
14098 {
14099   mips_elf_hash_table (info)->insn32 = on;
14100 }
14101 \f
14102 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
14103
14104 struct mips_mach_extension
14105 {
14106   unsigned long extension, base;
14107 };
14108
14109
14110 /* An array describing how BFD machines relate to one another.  The entries
14111    are ordered topologically with MIPS I extensions listed last.  */
14112
14113 static const struct mips_mach_extension mips_mach_extensions[] =
14114 {
14115   /* MIPS64r2 extensions.  */
14116   { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 },
14117   { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
14118   { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
14119   { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
14120   { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64r2 },
14121
14122   /* MIPS64 extensions.  */
14123   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
14124   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
14125   { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
14126
14127   /* MIPS V extensions.  */
14128   { bfd_mach_mipsisa64, bfd_mach_mips5 },
14129
14130   /* R10000 extensions.  */
14131   { bfd_mach_mips12000, bfd_mach_mips10000 },
14132   { bfd_mach_mips14000, bfd_mach_mips10000 },
14133   { bfd_mach_mips16000, bfd_mach_mips10000 },
14134
14135   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
14136      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
14137      better to allow vr5400 and vr5500 code to be merged anyway, since
14138      many libraries will just use the core ISA.  Perhaps we could add
14139      some sort of ASE flag if this ever proves a problem.  */
14140   { bfd_mach_mips5500, bfd_mach_mips5400 },
14141   { bfd_mach_mips5400, bfd_mach_mips5000 },
14142
14143   /* MIPS IV extensions.  */
14144   { bfd_mach_mips5, bfd_mach_mips8000 },
14145   { bfd_mach_mips10000, bfd_mach_mips8000 },
14146   { bfd_mach_mips5000, bfd_mach_mips8000 },
14147   { bfd_mach_mips7000, bfd_mach_mips8000 },
14148   { bfd_mach_mips9000, bfd_mach_mips8000 },
14149
14150   /* VR4100 extensions.  */
14151   { bfd_mach_mips4120, bfd_mach_mips4100 },
14152   { bfd_mach_mips4111, bfd_mach_mips4100 },
14153
14154   /* MIPS III extensions.  */
14155   { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
14156   { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
14157   { bfd_mach_mips8000, bfd_mach_mips4000 },
14158   { bfd_mach_mips4650, bfd_mach_mips4000 },
14159   { bfd_mach_mips4600, bfd_mach_mips4000 },
14160   { bfd_mach_mips4400, bfd_mach_mips4000 },
14161   { bfd_mach_mips4300, bfd_mach_mips4000 },
14162   { bfd_mach_mips4100, bfd_mach_mips4000 },
14163   { bfd_mach_mips4010, bfd_mach_mips4000 },
14164   { bfd_mach_mips5900, bfd_mach_mips4000 },
14165
14166   /* MIPS32 extensions.  */
14167   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
14168
14169   /* MIPS II extensions.  */
14170   { bfd_mach_mips4000, bfd_mach_mips6000 },
14171   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
14172
14173   /* MIPS I extensions.  */
14174   { bfd_mach_mips6000, bfd_mach_mips3000 },
14175   { bfd_mach_mips3900, bfd_mach_mips3000 }
14176 };
14177
14178 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
14179
14180 static bfd_boolean
14181 mips_mach_extends_p (unsigned long base, unsigned long extension)
14182 {
14183   size_t i;
14184
14185   if (extension == base)
14186     return TRUE;
14187
14188   if (base == bfd_mach_mipsisa32
14189       && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
14190     return TRUE;
14191
14192   if (base == bfd_mach_mipsisa32r2
14193       && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
14194     return TRUE;
14195
14196   for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
14197     if (extension == mips_mach_extensions[i].extension)
14198       {
14199         extension = mips_mach_extensions[i].base;
14200         if (extension == base)
14201           return TRUE;
14202       }
14203
14204   return FALSE;
14205 }
14206
14207 /* Return the BFD mach for each .MIPS.abiflags ISA Extension.  */
14208
14209 static unsigned long
14210 bfd_mips_isa_ext_mach (unsigned int isa_ext)
14211 {
14212   switch (isa_ext)
14213     {
14214     case AFL_EXT_3900:        return bfd_mach_mips3900;
14215     case AFL_EXT_4010:        return bfd_mach_mips4010;
14216     case AFL_EXT_4100:        return bfd_mach_mips4100;
14217     case AFL_EXT_4111:        return bfd_mach_mips4111;
14218     case AFL_EXT_4120:        return bfd_mach_mips4120;
14219     case AFL_EXT_4650:        return bfd_mach_mips4650;
14220     case AFL_EXT_5400:        return bfd_mach_mips5400;
14221     case AFL_EXT_5500:        return bfd_mach_mips5500;
14222     case AFL_EXT_5900:        return bfd_mach_mips5900;
14223     case AFL_EXT_10000:       return bfd_mach_mips10000;
14224     case AFL_EXT_LOONGSON_2E: return bfd_mach_mips_loongson_2e;
14225     case AFL_EXT_LOONGSON_2F: return bfd_mach_mips_loongson_2f;
14226     case AFL_EXT_LOONGSON_3A: return bfd_mach_mips_loongson_3a;
14227     case AFL_EXT_SB1:         return bfd_mach_mips_sb1;
14228     case AFL_EXT_OCTEON:      return bfd_mach_mips_octeon;
14229     case AFL_EXT_OCTEONP:     return bfd_mach_mips_octeonp;
14230     case AFL_EXT_OCTEON2:     return bfd_mach_mips_octeon2;
14231     case AFL_EXT_XLR:         return bfd_mach_mips_xlr;
14232     default:                  return bfd_mach_mips3000;
14233     }
14234 }
14235
14236 /* Return the .MIPS.abiflags value representing each ISA Extension.  */
14237
14238 unsigned int
14239 bfd_mips_isa_ext (bfd *abfd)
14240 {
14241   switch (bfd_get_mach (abfd))
14242     {
14243     case bfd_mach_mips3900:         return AFL_EXT_3900;
14244     case bfd_mach_mips4010:         return AFL_EXT_4010;
14245     case bfd_mach_mips4100:         return AFL_EXT_4100;
14246     case bfd_mach_mips4111:         return AFL_EXT_4111;
14247     case bfd_mach_mips4120:         return AFL_EXT_4120;
14248     case bfd_mach_mips4650:         return AFL_EXT_4650;
14249     case bfd_mach_mips5400:         return AFL_EXT_5400;
14250     case bfd_mach_mips5500:         return AFL_EXT_5500;
14251     case bfd_mach_mips5900:         return AFL_EXT_5900;
14252     case bfd_mach_mips10000:        return AFL_EXT_10000;
14253     case bfd_mach_mips_loongson_2e: return AFL_EXT_LOONGSON_2E;
14254     case bfd_mach_mips_loongson_2f: return AFL_EXT_LOONGSON_2F;
14255     case bfd_mach_mips_loongson_3a: return AFL_EXT_LOONGSON_3A;
14256     case bfd_mach_mips_sb1:         return AFL_EXT_SB1;
14257     case bfd_mach_mips_octeon:      return AFL_EXT_OCTEON;
14258     case bfd_mach_mips_octeonp:     return AFL_EXT_OCTEONP;
14259     case bfd_mach_mips_octeon3:     return AFL_EXT_OCTEON3;
14260     case bfd_mach_mips_octeon2:     return AFL_EXT_OCTEON2;
14261     case bfd_mach_mips_xlr:         return AFL_EXT_XLR;
14262     default:                        return 0;
14263     }
14264 }
14265
14266 /* Encode ISA level and revision as a single value.  */
14267 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14268
14269 /* Decode a single value into level and revision.  */
14270 #define ISA_LEVEL(LEVREV)  ((LEVREV) >> 3)
14271 #define ISA_REV(LEVREV)    ((LEVREV) & 0x7)
14272
14273 /* Update the isa_level, isa_rev, isa_ext fields of abiflags.  */
14274
14275 static void
14276 update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags)
14277 {
14278   int new_isa = 0;
14279   switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
14280     {
14281     case E_MIPS_ARCH_1:    new_isa = LEVEL_REV (1, 0); break;
14282     case E_MIPS_ARCH_2:    new_isa = LEVEL_REV (2, 0); break;
14283     case E_MIPS_ARCH_3:    new_isa = LEVEL_REV (3, 0); break;
14284     case E_MIPS_ARCH_4:    new_isa = LEVEL_REV (4, 0); break;
14285     case E_MIPS_ARCH_5:    new_isa = LEVEL_REV (5, 0); break;
14286     case E_MIPS_ARCH_32:   new_isa = LEVEL_REV (32, 1); break;
14287     case E_MIPS_ARCH_32R2: new_isa = LEVEL_REV (32, 2); break;
14288     case E_MIPS_ARCH_32R6: new_isa = LEVEL_REV (32, 6); break;
14289     case E_MIPS_ARCH_64:   new_isa = LEVEL_REV (64, 1); break;
14290     case E_MIPS_ARCH_64R2: new_isa = LEVEL_REV (64, 2); break;
14291     case E_MIPS_ARCH_64R6: new_isa = LEVEL_REV (64, 6); break;
14292     default:
14293       _bfd_error_handler
14294         /* xgettext:c-format */
14295         (_("%B: Unknown architecture %s"),
14296          abfd, bfd_printable_name (abfd));
14297     }
14298
14299   if (new_isa > LEVEL_REV (abiflags->isa_level, abiflags->isa_rev))
14300     {
14301       abiflags->isa_level = ISA_LEVEL (new_isa);
14302       abiflags->isa_rev = ISA_REV (new_isa);
14303     }
14304
14305   /* Update the isa_ext if ABFD describes a further extension.  */
14306   if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags->isa_ext),
14307                            bfd_get_mach (abfd)))
14308     abiflags->isa_ext = bfd_mips_isa_ext (abfd);
14309 }
14310
14311 /* Return true if the given ELF header flags describe a 32-bit binary.  */
14312
14313 static bfd_boolean
14314 mips_32bit_flags_p (flagword flags)
14315 {
14316   return ((flags & EF_MIPS_32BITMODE) != 0
14317           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
14318           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
14319           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
14320           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
14321           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
14322           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2
14323           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6);
14324 }
14325
14326 /* Infer the content of the ABI flags based on the elf header.  */
14327
14328 static void
14329 infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags)
14330 {
14331   obj_attribute *in_attr;
14332
14333   memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0));
14334   update_mips_abiflags_isa (abfd, abiflags);
14335
14336   if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags))
14337     abiflags->gpr_size = AFL_REG_32;
14338   else
14339     abiflags->gpr_size = AFL_REG_64;
14340
14341   abiflags->cpr1_size = AFL_REG_NONE;
14342
14343   in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
14344   abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14345
14346   if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE
14347       || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX
14348       || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14349           && abiflags->gpr_size == AFL_REG_32))
14350     abiflags->cpr1_size = AFL_REG_32;
14351   else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14352            || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64
14353            || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A)
14354     abiflags->cpr1_size = AFL_REG_64;
14355
14356   abiflags->cpr2_size = AFL_REG_NONE;
14357
14358   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14359     abiflags->ases |= AFL_ASE_MDMX;
14360   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14361     abiflags->ases |= AFL_ASE_MIPS16;
14362   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14363     abiflags->ases |= AFL_ASE_MICROMIPS;
14364
14365   if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY
14366       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT
14367       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A
14368       && abiflags->isa_level >= 32
14369       && abiflags->isa_ext != AFL_EXT_LOONGSON_3A)
14370     abiflags->flags1 |= AFL_FLAGS1_ODDSPREG;
14371 }
14372
14373 /* We need to use a special link routine to handle the .reginfo and
14374    the .mdebug sections.  We need to merge all instances of these
14375    sections together, not write them all out sequentially.  */
14376
14377 bfd_boolean
14378 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
14379 {
14380   asection *o;
14381   struct bfd_link_order *p;
14382   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
14383   asection *rtproc_sec, *abiflags_sec;
14384   Elf32_RegInfo reginfo;
14385   struct ecoff_debug_info debug;
14386   struct mips_htab_traverse_info hti;
14387   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14388   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
14389   HDRR *symhdr = &debug.symbolic_header;
14390   void *mdebug_handle = NULL;
14391   asection *s;
14392   EXTR esym;
14393   unsigned int i;
14394   bfd_size_type amt;
14395   struct mips_elf_link_hash_table *htab;
14396
14397   static const char * const secname[] =
14398   {
14399     ".text", ".init", ".fini", ".data",
14400     ".rodata", ".sdata", ".sbss", ".bss"
14401   };
14402   static const int sc[] =
14403   {
14404     scText, scInit, scFini, scData,
14405     scRData, scSData, scSBss, scBss
14406   };
14407
14408   /* Sort the dynamic symbols so that those with GOT entries come after
14409      those without.  */
14410   htab = mips_elf_hash_table (info);
14411   BFD_ASSERT (htab != NULL);
14412
14413   if (!mips_elf_sort_hash_table (abfd, info))
14414     return FALSE;
14415
14416   /* Create any scheduled LA25 stubs.  */
14417   hti.info = info;
14418   hti.output_bfd = abfd;
14419   hti.error = FALSE;
14420   htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
14421   if (hti.error)
14422     return FALSE;
14423
14424   /* Get a value for the GP register.  */
14425   if (elf_gp (abfd) == 0)
14426     {
14427       struct bfd_link_hash_entry *h;
14428
14429       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
14430       if (h != NULL && h->type == bfd_link_hash_defined)
14431         elf_gp (abfd) = (h->u.def.value
14432                          + h->u.def.section->output_section->vma
14433                          + h->u.def.section->output_offset);
14434       else if (htab->is_vxworks
14435                && (h = bfd_link_hash_lookup (info->hash,
14436                                              "_GLOBAL_OFFSET_TABLE_",
14437                                              FALSE, FALSE, TRUE))
14438                && h->type == bfd_link_hash_defined)
14439         elf_gp (abfd) = (h->u.def.section->output_section->vma
14440                          + h->u.def.section->output_offset
14441                          + h->u.def.value);
14442       else if (bfd_link_relocatable (info))
14443         {
14444           bfd_vma lo = MINUS_ONE;
14445
14446           /* Find the GP-relative section with the lowest offset.  */
14447           for (o = abfd->sections; o != NULL; o = o->next)
14448             if (o->vma < lo
14449                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
14450               lo = o->vma;
14451
14452           /* And calculate GP relative to that.  */
14453           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
14454         }
14455       else
14456         {
14457           /* If the relocate_section function needs to do a reloc
14458              involving the GP value, it should make a reloc_dangerous
14459              callback to warn that GP is not defined.  */
14460         }
14461     }
14462
14463   /* Go through the sections and collect the .reginfo and .mdebug
14464      information.  */
14465   abiflags_sec = NULL;
14466   reginfo_sec = NULL;
14467   mdebug_sec = NULL;
14468   gptab_data_sec = NULL;
14469   gptab_bss_sec = NULL;
14470   for (o = abfd->sections; o != NULL; o = o->next)
14471     {
14472       if (strcmp (o->name, ".MIPS.abiflags") == 0)
14473         {
14474           /* We have found the .MIPS.abiflags section in the output file.
14475              Look through all the link_orders comprising it and remove them.
14476              The data is merged in _bfd_mips_elf_merge_private_bfd_data.  */
14477           for (p = o->map_head.link_order; p != NULL; p = p->next)
14478             {
14479               asection *input_section;
14480
14481               if (p->type != bfd_indirect_link_order)
14482                 {
14483                   if (p->type == bfd_data_link_order)
14484                     continue;
14485                   abort ();
14486                 }
14487
14488               input_section = p->u.indirect.section;
14489
14490               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14491                  elf_link_input_bfd ignores this section.  */
14492               input_section->flags &= ~SEC_HAS_CONTENTS;
14493             }
14494
14495           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
14496           BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0));
14497
14498           /* Skip this section later on (I don't think this currently
14499              matters, but someday it might).  */
14500           o->map_head.link_order = NULL;
14501
14502           abiflags_sec = o;
14503         }
14504
14505       if (strcmp (o->name, ".reginfo") == 0)
14506         {
14507           memset (&reginfo, 0, sizeof reginfo);
14508
14509           /* We have found the .reginfo section in the output file.
14510              Look through all the link_orders comprising it and merge
14511              the information together.  */
14512           for (p = o->map_head.link_order; p != NULL; p = p->next)
14513             {
14514               asection *input_section;
14515               bfd *input_bfd;
14516               Elf32_External_RegInfo ext;
14517               Elf32_RegInfo sub;
14518
14519               if (p->type != bfd_indirect_link_order)
14520                 {
14521                   if (p->type == bfd_data_link_order)
14522                     continue;
14523                   abort ();
14524                 }
14525
14526               input_section = p->u.indirect.section;
14527               input_bfd = input_section->owner;
14528
14529               if (! bfd_get_section_contents (input_bfd, input_section,
14530                                               &ext, 0, sizeof ext))
14531                 return FALSE;
14532
14533               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
14534
14535               reginfo.ri_gprmask |= sub.ri_gprmask;
14536               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
14537               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
14538               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
14539               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
14540
14541               /* ri_gp_value is set by the function
14542                  mips_elf32_section_processing when the section is
14543                  finally written out.  */
14544
14545               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14546                  elf_link_input_bfd ignores this section.  */
14547               input_section->flags &= ~SEC_HAS_CONTENTS;
14548             }
14549
14550           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
14551           BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
14552
14553           /* Skip this section later on (I don't think this currently
14554              matters, but someday it might).  */
14555           o->map_head.link_order = NULL;
14556
14557           reginfo_sec = o;
14558         }
14559
14560       if (strcmp (o->name, ".mdebug") == 0)
14561         {
14562           struct extsym_info einfo;
14563           bfd_vma last;
14564
14565           /* We have found the .mdebug section in the output file.
14566              Look through all the link_orders comprising it and merge
14567              the information together.  */
14568           symhdr->magic = swap->sym_magic;
14569           /* FIXME: What should the version stamp be?  */
14570           symhdr->vstamp = 0;
14571           symhdr->ilineMax = 0;
14572           symhdr->cbLine = 0;
14573           symhdr->idnMax = 0;
14574           symhdr->ipdMax = 0;
14575           symhdr->isymMax = 0;
14576           symhdr->ioptMax = 0;
14577           symhdr->iauxMax = 0;
14578           symhdr->issMax = 0;
14579           symhdr->issExtMax = 0;
14580           symhdr->ifdMax = 0;
14581           symhdr->crfd = 0;
14582           symhdr->iextMax = 0;
14583
14584           /* We accumulate the debugging information itself in the
14585              debug_info structure.  */
14586           debug.line = NULL;
14587           debug.external_dnr = NULL;
14588           debug.external_pdr = NULL;
14589           debug.external_sym = NULL;
14590           debug.external_opt = NULL;
14591           debug.external_aux = NULL;
14592           debug.ss = NULL;
14593           debug.ssext = debug.ssext_end = NULL;
14594           debug.external_fdr = NULL;
14595           debug.external_rfd = NULL;
14596           debug.external_ext = debug.external_ext_end = NULL;
14597
14598           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
14599           if (mdebug_handle == NULL)
14600             return FALSE;
14601
14602           esym.jmptbl = 0;
14603           esym.cobol_main = 0;
14604           esym.weakext = 0;
14605           esym.reserved = 0;
14606           esym.ifd = ifdNil;
14607           esym.asym.iss = issNil;
14608           esym.asym.st = stLocal;
14609           esym.asym.reserved = 0;
14610           esym.asym.index = indexNil;
14611           last = 0;
14612           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
14613             {
14614               esym.asym.sc = sc[i];
14615               s = bfd_get_section_by_name (abfd, secname[i]);
14616               if (s != NULL)
14617                 {
14618                   esym.asym.value = s->vma;
14619                   last = s->vma + s->size;
14620                 }
14621               else
14622                 esym.asym.value = last;
14623               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
14624                                                  secname[i], &esym))
14625                 return FALSE;
14626             }
14627
14628           for (p = o->map_head.link_order; p != NULL; p = p->next)
14629             {
14630               asection *input_section;
14631               bfd *input_bfd;
14632               const struct ecoff_debug_swap *input_swap;
14633               struct ecoff_debug_info input_debug;
14634               char *eraw_src;
14635               char *eraw_end;
14636
14637               if (p->type != bfd_indirect_link_order)
14638                 {
14639                   if (p->type == bfd_data_link_order)
14640                     continue;
14641                   abort ();
14642                 }
14643
14644               input_section = p->u.indirect.section;
14645               input_bfd = input_section->owner;
14646
14647               if (!is_mips_elf (input_bfd))
14648                 {
14649                   /* I don't know what a non MIPS ELF bfd would be
14650                      doing with a .mdebug section, but I don't really
14651                      want to deal with it.  */
14652                   continue;
14653                 }
14654
14655               input_swap = (get_elf_backend_data (input_bfd)
14656                             ->elf_backend_ecoff_debug_swap);
14657
14658               BFD_ASSERT (p->size == input_section->size);
14659
14660               /* The ECOFF linking code expects that we have already
14661                  read in the debugging information and set up an
14662                  ecoff_debug_info structure, so we do that now.  */
14663               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
14664                                                    &input_debug))
14665                 return FALSE;
14666
14667               if (! (bfd_ecoff_debug_accumulate
14668                      (mdebug_handle, abfd, &debug, swap, input_bfd,
14669                       &input_debug, input_swap, info)))
14670                 return FALSE;
14671
14672               /* Loop through the external symbols.  For each one with
14673                  interesting information, try to find the symbol in
14674                  the linker global hash table and save the information
14675                  for the output external symbols.  */
14676               eraw_src = input_debug.external_ext;
14677               eraw_end = (eraw_src
14678                           + (input_debug.symbolic_header.iextMax
14679                              * input_swap->external_ext_size));
14680               for (;
14681                    eraw_src < eraw_end;
14682                    eraw_src += input_swap->external_ext_size)
14683                 {
14684                   EXTR ext;
14685                   const char *name;
14686                   struct mips_elf_link_hash_entry *h;
14687
14688                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
14689                   if (ext.asym.sc == scNil
14690                       || ext.asym.sc == scUndefined
14691                       || ext.asym.sc == scSUndefined)
14692                     continue;
14693
14694                   name = input_debug.ssext + ext.asym.iss;
14695                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
14696                                                  name, FALSE, FALSE, TRUE);
14697                   if (h == NULL || h->esym.ifd != -2)
14698                     continue;
14699
14700                   if (ext.ifd != -1)
14701                     {
14702                       BFD_ASSERT (ext.ifd
14703                                   < input_debug.symbolic_header.ifdMax);
14704                       ext.ifd = input_debug.ifdmap[ext.ifd];
14705                     }
14706
14707                   h->esym = ext;
14708                 }
14709
14710               /* Free up the information we just read.  */
14711               free (input_debug.line);
14712               free (input_debug.external_dnr);
14713               free (input_debug.external_pdr);
14714               free (input_debug.external_sym);
14715               free (input_debug.external_opt);
14716               free (input_debug.external_aux);
14717               free (input_debug.ss);
14718               free (input_debug.ssext);
14719               free (input_debug.external_fdr);
14720               free (input_debug.external_rfd);
14721               free (input_debug.external_ext);
14722
14723               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14724                  elf_link_input_bfd ignores this section.  */
14725               input_section->flags &= ~SEC_HAS_CONTENTS;
14726             }
14727
14728           if (SGI_COMPAT (abfd) && bfd_link_pic (info))
14729             {
14730               /* Create .rtproc section.  */
14731               rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
14732               if (rtproc_sec == NULL)
14733                 {
14734                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
14735                                     | SEC_LINKER_CREATED | SEC_READONLY);
14736
14737                   rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
14738                                                                    ".rtproc",
14739                                                                    flags);
14740                   if (rtproc_sec == NULL
14741                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
14742                     return FALSE;
14743                 }
14744
14745               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
14746                                                      info, rtproc_sec,
14747                                                      &debug))
14748                 return FALSE;
14749             }
14750
14751           /* Build the external symbol information.  */
14752           einfo.abfd = abfd;
14753           einfo.info = info;
14754           einfo.debug = &debug;
14755           einfo.swap = swap;
14756           einfo.failed = FALSE;
14757           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
14758                                        mips_elf_output_extsym, &einfo);
14759           if (einfo.failed)
14760             return FALSE;
14761
14762           /* Set the size of the .mdebug section.  */
14763           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
14764
14765           /* Skip this section later on (I don't think this currently
14766              matters, but someday it might).  */
14767           o->map_head.link_order = NULL;
14768
14769           mdebug_sec = o;
14770         }
14771
14772       if (CONST_STRNEQ (o->name, ".gptab."))
14773         {
14774           const char *subname;
14775           unsigned int c;
14776           Elf32_gptab *tab;
14777           Elf32_External_gptab *ext_tab;
14778           unsigned int j;
14779
14780           /* The .gptab.sdata and .gptab.sbss sections hold
14781              information describing how the small data area would
14782              change depending upon the -G switch.  These sections
14783              not used in executables files.  */
14784           if (! bfd_link_relocatable (info))
14785             {
14786               for (p = o->map_head.link_order; p != NULL; p = p->next)
14787                 {
14788                   asection *input_section;
14789
14790                   if (p->type != bfd_indirect_link_order)
14791                     {
14792                       if (p->type == bfd_data_link_order)
14793                         continue;
14794                       abort ();
14795                     }
14796
14797                   input_section = p->u.indirect.section;
14798
14799                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
14800                      elf_link_input_bfd ignores this section.  */
14801                   input_section->flags &= ~SEC_HAS_CONTENTS;
14802                 }
14803
14804               /* Skip this section later on (I don't think this
14805                  currently matters, but someday it might).  */
14806               o->map_head.link_order = NULL;
14807
14808               /* Really remove the section.  */
14809               bfd_section_list_remove (abfd, o);
14810               --abfd->section_count;
14811
14812               continue;
14813             }
14814
14815           /* There is one gptab for initialized data, and one for
14816              uninitialized data.  */
14817           if (strcmp (o->name, ".gptab.sdata") == 0)
14818             gptab_data_sec = o;
14819           else if (strcmp (o->name, ".gptab.sbss") == 0)
14820             gptab_bss_sec = o;
14821           else
14822             {
14823               _bfd_error_handler
14824                 /* xgettext:c-format */
14825                 (_("%s: illegal section name `%s'"),
14826                  bfd_get_filename (abfd), o->name);
14827               bfd_set_error (bfd_error_nonrepresentable_section);
14828               return FALSE;
14829             }
14830
14831           /* The linker script always combines .gptab.data and
14832              .gptab.sdata into .gptab.sdata, and likewise for
14833              .gptab.bss and .gptab.sbss.  It is possible that there is
14834              no .sdata or .sbss section in the output file, in which
14835              case we must change the name of the output section.  */
14836           subname = o->name + sizeof ".gptab" - 1;
14837           if (bfd_get_section_by_name (abfd, subname) == NULL)
14838             {
14839               if (o == gptab_data_sec)
14840                 o->name = ".gptab.data";
14841               else
14842                 o->name = ".gptab.bss";
14843               subname = o->name + sizeof ".gptab" - 1;
14844               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
14845             }
14846
14847           /* Set up the first entry.  */
14848           c = 1;
14849           amt = c * sizeof (Elf32_gptab);
14850           tab = bfd_malloc (amt);
14851           if (tab == NULL)
14852             return FALSE;
14853           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
14854           tab[0].gt_header.gt_unused = 0;
14855
14856           /* Combine the input sections.  */
14857           for (p = o->map_head.link_order; p != NULL; p = p->next)
14858             {
14859               asection *input_section;
14860               bfd *input_bfd;
14861               bfd_size_type size;
14862               unsigned long last;
14863               bfd_size_type gpentry;
14864
14865               if (p->type != bfd_indirect_link_order)
14866                 {
14867                   if (p->type == bfd_data_link_order)
14868                     continue;
14869                   abort ();
14870                 }
14871
14872               input_section = p->u.indirect.section;
14873               input_bfd = input_section->owner;
14874
14875               /* Combine the gptab entries for this input section one
14876                  by one.  We know that the input gptab entries are
14877                  sorted by ascending -G value.  */
14878               size = input_section->size;
14879               last = 0;
14880               for (gpentry = sizeof (Elf32_External_gptab);
14881                    gpentry < size;
14882                    gpentry += sizeof (Elf32_External_gptab))
14883                 {
14884                   Elf32_External_gptab ext_gptab;
14885                   Elf32_gptab int_gptab;
14886                   unsigned long val;
14887                   unsigned long add;
14888                   bfd_boolean exact;
14889                   unsigned int look;
14890
14891                   if (! (bfd_get_section_contents
14892                          (input_bfd, input_section, &ext_gptab, gpentry,
14893                           sizeof (Elf32_External_gptab))))
14894                     {
14895                       free (tab);
14896                       return FALSE;
14897                     }
14898
14899                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
14900                                                 &int_gptab);
14901                   val = int_gptab.gt_entry.gt_g_value;
14902                   add = int_gptab.gt_entry.gt_bytes - last;
14903
14904                   exact = FALSE;
14905                   for (look = 1; look < c; look++)
14906                     {
14907                       if (tab[look].gt_entry.gt_g_value >= val)
14908                         tab[look].gt_entry.gt_bytes += add;
14909
14910                       if (tab[look].gt_entry.gt_g_value == val)
14911                         exact = TRUE;
14912                     }
14913
14914                   if (! exact)
14915                     {
14916                       Elf32_gptab *new_tab;
14917                       unsigned int max;
14918
14919                       /* We need a new table entry.  */
14920                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
14921                       new_tab = bfd_realloc (tab, amt);
14922                       if (new_tab == NULL)
14923                         {
14924                           free (tab);
14925                           return FALSE;
14926                         }
14927                       tab = new_tab;
14928                       tab[c].gt_entry.gt_g_value = val;
14929                       tab[c].gt_entry.gt_bytes = add;
14930
14931                       /* Merge in the size for the next smallest -G
14932                          value, since that will be implied by this new
14933                          value.  */
14934                       max = 0;
14935                       for (look = 1; look < c; look++)
14936                         {
14937                           if (tab[look].gt_entry.gt_g_value < val
14938                               && (max == 0
14939                                   || (tab[look].gt_entry.gt_g_value
14940                                       > tab[max].gt_entry.gt_g_value)))
14941                             max = look;
14942                         }
14943                       if (max != 0)
14944                         tab[c].gt_entry.gt_bytes +=
14945                           tab[max].gt_entry.gt_bytes;
14946
14947                       ++c;
14948                     }
14949
14950                   last = int_gptab.gt_entry.gt_bytes;
14951                 }
14952
14953               /* Hack: reset the SEC_HAS_CONTENTS flag so that
14954                  elf_link_input_bfd ignores this section.  */
14955               input_section->flags &= ~SEC_HAS_CONTENTS;
14956             }
14957
14958           /* The table must be sorted by -G value.  */
14959           if (c > 2)
14960             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
14961
14962           /* Swap out the table.  */
14963           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
14964           ext_tab = bfd_alloc (abfd, amt);
14965           if (ext_tab == NULL)
14966             {
14967               free (tab);
14968               return FALSE;
14969             }
14970
14971           for (j = 0; j < c; j++)
14972             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
14973           free (tab);
14974
14975           o->size = c * sizeof (Elf32_External_gptab);
14976           o->contents = (bfd_byte *) ext_tab;
14977
14978           /* Skip this section later on (I don't think this currently
14979              matters, but someday it might).  */
14980           o->map_head.link_order = NULL;
14981         }
14982     }
14983
14984   /* Invoke the regular ELF backend linker to do all the work.  */
14985   if (!bfd_elf_final_link (abfd, info))
14986     return FALSE;
14987
14988   /* Now write out the computed sections.  */
14989
14990   if (abiflags_sec != NULL)
14991     {
14992       Elf_External_ABIFlags_v0 ext;
14993       Elf_Internal_ABIFlags_v0 *abiflags;
14994
14995       abiflags = &mips_elf_tdata (abfd)->abiflags;
14996
14997       /* Set up the abiflags if no valid input sections were found.  */
14998       if (!mips_elf_tdata (abfd)->abiflags_valid)
14999         {
15000           infer_mips_abiflags (abfd, abiflags);
15001           mips_elf_tdata (abfd)->abiflags_valid = TRUE;
15002         }
15003       bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext);
15004       if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext))
15005         return FALSE;
15006     }
15007
15008   if (reginfo_sec != NULL)
15009     {
15010       Elf32_External_RegInfo ext;
15011
15012       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
15013       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
15014         return FALSE;
15015     }
15016
15017   if (mdebug_sec != NULL)
15018     {
15019       BFD_ASSERT (abfd->output_has_begun);
15020       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
15021                                                swap, info,
15022                                                mdebug_sec->filepos))
15023         return FALSE;
15024
15025       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
15026     }
15027
15028   if (gptab_data_sec != NULL)
15029     {
15030       if (! bfd_set_section_contents (abfd, gptab_data_sec,
15031                                       gptab_data_sec->contents,
15032                                       0, gptab_data_sec->size))
15033         return FALSE;
15034     }
15035
15036   if (gptab_bss_sec != NULL)
15037     {
15038       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
15039                                       gptab_bss_sec->contents,
15040                                       0, gptab_bss_sec->size))
15041         return FALSE;
15042     }
15043
15044   if (SGI_COMPAT (abfd))
15045     {
15046       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
15047       if (rtproc_sec != NULL)
15048         {
15049           if (! bfd_set_section_contents (abfd, rtproc_sec,
15050                                           rtproc_sec->contents,
15051                                           0, rtproc_sec->size))
15052             return FALSE;
15053         }
15054     }
15055
15056   return TRUE;
15057 }
15058 \f
15059 /* Merge object file header flags from IBFD into OBFD.  Raise an error
15060    if there are conflicting settings.  */
15061
15062 static bfd_boolean
15063 mips_elf_merge_obj_e_flags (bfd *ibfd, struct bfd_link_info *info)
15064 {
15065   bfd *obfd = info->output_bfd;
15066   struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15067   flagword old_flags;
15068   flagword new_flags;
15069   bfd_boolean ok;
15070
15071   new_flags = elf_elfheader (ibfd)->e_flags;
15072   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
15073   old_flags = elf_elfheader (obfd)->e_flags;
15074
15075   /* Check flag compatibility.  */
15076
15077   new_flags &= ~EF_MIPS_NOREORDER;
15078   old_flags &= ~EF_MIPS_NOREORDER;
15079
15080   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
15081      doesn't seem to matter.  */
15082   new_flags &= ~EF_MIPS_XGOT;
15083   old_flags &= ~EF_MIPS_XGOT;
15084
15085   /* MIPSpro generates ucode info in n64 objects.  Again, we should
15086      just be able to ignore this.  */
15087   new_flags &= ~EF_MIPS_UCODE;
15088   old_flags &= ~EF_MIPS_UCODE;
15089
15090   /* DSOs should only be linked with CPIC code.  */
15091   if ((ibfd->flags & DYNAMIC) != 0)
15092     new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
15093
15094   if (new_flags == old_flags)
15095     return TRUE;
15096
15097   ok = TRUE;
15098
15099   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
15100       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
15101     {
15102       _bfd_error_handler
15103         (_("%B: warning: linking abicalls files with non-abicalls files"),
15104          ibfd);
15105       ok = TRUE;
15106     }
15107
15108   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
15109     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
15110   if (! (new_flags & EF_MIPS_PIC))
15111     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
15112
15113   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15114   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15115
15116   /* Compare the ISAs.  */
15117   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
15118     {
15119       _bfd_error_handler
15120         (_("%B: linking 32-bit code with 64-bit code"),
15121          ibfd);
15122       ok = FALSE;
15123     }
15124   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
15125     {
15126       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
15127       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
15128         {
15129           /* Copy the architecture info from IBFD to OBFD.  Also copy
15130              the 32-bit flag (if set) so that we continue to recognise
15131              OBFD as a 32-bit binary.  */
15132           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
15133           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
15134           elf_elfheader (obfd)->e_flags
15135             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15136
15137           /* Update the ABI flags isa_level, isa_rev, isa_ext fields.  */
15138           update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15139
15140           /* Copy across the ABI flags if OBFD doesn't use them
15141              and if that was what caused us to treat IBFD as 32-bit.  */
15142           if ((old_flags & EF_MIPS_ABI) == 0
15143               && mips_32bit_flags_p (new_flags)
15144               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
15145             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
15146         }
15147       else
15148         {
15149           /* The ISAs aren't compatible.  */
15150           _bfd_error_handler
15151             /* xgettext:c-format */
15152             (_("%B: linking %s module with previous %s modules"),
15153              ibfd,
15154              bfd_printable_name (ibfd),
15155              bfd_printable_name (obfd));
15156           ok = FALSE;
15157         }
15158     }
15159
15160   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15161   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15162
15163   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
15164      does set EI_CLASS differently from any 32-bit ABI.  */
15165   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
15166       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15167           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15168     {
15169       /* Only error if both are set (to different values).  */
15170       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
15171           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15172               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15173         {
15174           _bfd_error_handler
15175             /* xgettext:c-format */
15176             (_("%B: ABI mismatch: linking %s module with previous %s modules"),
15177              ibfd,
15178              elf_mips_abi_name (ibfd),
15179              elf_mips_abi_name (obfd));
15180           ok = FALSE;
15181         }
15182       new_flags &= ~EF_MIPS_ABI;
15183       old_flags &= ~EF_MIPS_ABI;
15184     }
15185
15186   /* Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
15187      and allow arbitrary mixing of the remaining ASEs (retain the union).  */
15188   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
15189     {
15190       int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15191       int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15192       int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
15193       int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
15194       int micro_mis = old_m16 && new_micro;
15195       int m16_mis = old_micro && new_m16;
15196
15197       if (m16_mis || micro_mis)
15198         {
15199           _bfd_error_handler
15200             /* xgettext:c-format */
15201             (_("%B: ASE mismatch: linking %s module with previous %s modules"),
15202              ibfd,
15203              m16_mis ? "MIPS16" : "microMIPS",
15204              m16_mis ? "microMIPS" : "MIPS16");
15205           ok = FALSE;
15206         }
15207
15208       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
15209
15210       new_flags &= ~ EF_MIPS_ARCH_ASE;
15211       old_flags &= ~ EF_MIPS_ARCH_ASE;
15212     }
15213
15214   /* Compare NaN encodings.  */
15215   if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
15216     {
15217       /* xgettext:c-format */
15218       _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15219                           ibfd,
15220                           (new_flags & EF_MIPS_NAN2008
15221                            ? "-mnan=2008" : "-mnan=legacy"),
15222                           (old_flags & EF_MIPS_NAN2008
15223                            ? "-mnan=2008" : "-mnan=legacy"));
15224       ok = FALSE;
15225       new_flags &= ~EF_MIPS_NAN2008;
15226       old_flags &= ~EF_MIPS_NAN2008;
15227     }
15228
15229   /* Compare FP64 state.  */
15230   if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
15231     {
15232       /* xgettext:c-format */
15233       _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15234                           ibfd,
15235                           (new_flags & EF_MIPS_FP64
15236                            ? "-mfp64" : "-mfp32"),
15237                           (old_flags & EF_MIPS_FP64
15238                            ? "-mfp64" : "-mfp32"));
15239       ok = FALSE;
15240       new_flags &= ~EF_MIPS_FP64;
15241       old_flags &= ~EF_MIPS_FP64;
15242     }
15243
15244   /* Warn about any other mismatches */
15245   if (new_flags != old_flags)
15246     {
15247       /* xgettext:c-format */
15248       _bfd_error_handler
15249         (_("%B: uses different e_flags (0x%lx) fields than previous modules "
15250            "(0x%lx)"),
15251          ibfd, (unsigned long) new_flags,
15252          (unsigned long) old_flags);
15253       ok = FALSE;
15254     }
15255
15256   return ok;
15257 }
15258
15259 /* Merge object attributes from IBFD into OBFD.  Raise an error if
15260    there are conflicting attributes.  */
15261 static bfd_boolean
15262 mips_elf_merge_obj_attributes (bfd *ibfd, struct bfd_link_info *info)
15263 {
15264   bfd *obfd = info->output_bfd;
15265   obj_attribute *in_attr;
15266   obj_attribute *out_attr;
15267   bfd *abi_fp_bfd;
15268   bfd *abi_msa_bfd;
15269
15270   abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
15271   in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15272   if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY)
15273     mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15274
15275   abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd;
15276   if (!abi_msa_bfd
15277       && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15278     mips_elf_tdata (obfd)->abi_msa_bfd = ibfd;
15279
15280   if (!elf_known_obj_attributes_proc (obfd)[0].i)
15281     {
15282       /* This is the first object.  Copy the attributes.  */
15283       _bfd_elf_copy_obj_attributes (ibfd, obfd);
15284
15285       /* Use the Tag_null value to indicate the attributes have been
15286          initialized.  */
15287       elf_known_obj_attributes_proc (obfd)[0].i = 1;
15288
15289       return TRUE;
15290     }
15291
15292   /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
15293      non-conflicting ones.  */
15294   out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15295   if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
15296     {
15297       int out_fp, in_fp;
15298
15299       out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15300       in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15301       out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
15302       if (out_fp == Val_GNU_MIPS_ABI_FP_ANY)
15303         out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp;
15304       else if (out_fp == Val_GNU_MIPS_ABI_FP_XX
15305                && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15306                    || in_fp == Val_GNU_MIPS_ABI_FP_64
15307                    || in_fp == Val_GNU_MIPS_ABI_FP_64A))
15308         {
15309           mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15310           out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15311         }
15312       else if (in_fp == Val_GNU_MIPS_ABI_FP_XX
15313                && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15314                    || out_fp == Val_GNU_MIPS_ABI_FP_64
15315                    || out_fp == Val_GNU_MIPS_ABI_FP_64A))
15316         /* Keep the current setting.  */;
15317       else if (out_fp == Val_GNU_MIPS_ABI_FP_64A
15318                && in_fp == Val_GNU_MIPS_ABI_FP_64)
15319         {
15320           mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15321           out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15322         }
15323       else if (in_fp == Val_GNU_MIPS_ABI_FP_64A
15324                && out_fp == Val_GNU_MIPS_ABI_FP_64)
15325         /* Keep the current setting.  */;
15326       else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY)
15327         {
15328           const char *out_string, *in_string;
15329
15330           out_string = _bfd_mips_fp_abi_string (out_fp);
15331           in_string = _bfd_mips_fp_abi_string (in_fp);
15332           /* First warn about cases involving unrecognised ABIs.  */
15333           if (!out_string && !in_string)
15334             /* xgettext:c-format */
15335             _bfd_error_handler
15336               (_("Warning: %B uses unknown floating point ABI %d "
15337                  "(set by %B), %B uses unknown floating point ABI %d"),
15338                obfd, abi_fp_bfd, ibfd, out_fp, in_fp);
15339           else if (!out_string)
15340             _bfd_error_handler
15341               /* xgettext:c-format */
15342               (_("Warning: %B uses unknown floating point ABI %d "
15343                  "(set by %B), %B uses %s"),
15344                obfd, abi_fp_bfd, ibfd, out_fp, in_string);
15345           else if (!in_string)
15346             _bfd_error_handler
15347               /* xgettext:c-format */
15348               (_("Warning: %B uses %s (set by %B), "
15349                  "%B uses unknown floating point ABI %d"),
15350                obfd, abi_fp_bfd, ibfd, out_string, in_fp);
15351           else
15352             {
15353               /* If one of the bfds is soft-float, the other must be
15354                  hard-float.  The exact choice of hard-float ABI isn't
15355                  really relevant to the error message.  */
15356               if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15357                 out_string = "-mhard-float";
15358               else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15359                 in_string = "-mhard-float";
15360               _bfd_error_handler
15361                 /* xgettext:c-format */
15362                 (_("Warning: %B uses %s (set by %B), %B uses %s"),
15363                  obfd, abi_fp_bfd, ibfd, out_string, in_string);
15364             }
15365         }
15366     }
15367
15368   /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15369      non-conflicting ones.  */
15370   if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15371     {
15372       out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1;
15373       if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY)
15374         out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i;
15375       else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15376         switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15377           {
15378           case Val_GNU_MIPS_ABI_MSA_128:
15379             _bfd_error_handler
15380               /* xgettext:c-format */
15381               (_("Warning: %B uses %s (set by %B), "
15382                  "%B uses unknown MSA ABI %d"),
15383                obfd, abi_msa_bfd, ibfd,
15384                "-mmsa", in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15385             break;
15386
15387           default:
15388             switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i)
15389               {
15390               case Val_GNU_MIPS_ABI_MSA_128:
15391                 _bfd_error_handler
15392                   /* xgettext:c-format */
15393                   (_("Warning: %B uses unknown MSA ABI %d "
15394                      "(set by %B), %B uses %s"),
15395                      obfd, abi_msa_bfd, ibfd,
15396                      out_attr[Tag_GNU_MIPS_ABI_MSA].i, "-mmsa");
15397                   break;
15398
15399               default:
15400                 _bfd_error_handler
15401                   /* xgettext:c-format */
15402                   (_("Warning: %B uses unknown MSA ABI %d "
15403                      "(set by %B), %B uses unknown MSA ABI %d"),
15404                    obfd, abi_msa_bfd, ibfd,
15405                    out_attr[Tag_GNU_MIPS_ABI_MSA].i,
15406                    in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15407                 break;
15408               }
15409           }
15410     }
15411
15412   /* Merge Tag_compatibility attributes and any common GNU ones.  */
15413   return _bfd_elf_merge_object_attributes (ibfd, info);
15414 }
15415
15416 /* Merge object ABI flags from IBFD into OBFD.  Raise an error if
15417    there are conflicting settings.  */
15418
15419 static bfd_boolean
15420 mips_elf_merge_obj_abiflags (bfd *ibfd, bfd *obfd)
15421 {
15422   obj_attribute *out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15423   struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15424   struct mips_elf_obj_tdata *in_tdata = mips_elf_tdata (ibfd);
15425
15426   /* Update the output abiflags fp_abi using the computed fp_abi.  */
15427   out_tdata->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15428
15429 #define max(a, b) ((a) > (b) ? (a) : (b))
15430   /* Merge abiflags.  */
15431   out_tdata->abiflags.isa_level = max (out_tdata->abiflags.isa_level,
15432                                        in_tdata->abiflags.isa_level);
15433   out_tdata->abiflags.isa_rev = max (out_tdata->abiflags.isa_rev,
15434                                      in_tdata->abiflags.isa_rev);
15435   out_tdata->abiflags.gpr_size = max (out_tdata->abiflags.gpr_size,
15436                                       in_tdata->abiflags.gpr_size);
15437   out_tdata->abiflags.cpr1_size = max (out_tdata->abiflags.cpr1_size,
15438                                        in_tdata->abiflags.cpr1_size);
15439   out_tdata->abiflags.cpr2_size = max (out_tdata->abiflags.cpr2_size,
15440                                        in_tdata->abiflags.cpr2_size);
15441 #undef max
15442   out_tdata->abiflags.ases |= in_tdata->abiflags.ases;
15443   out_tdata->abiflags.flags1 |= in_tdata->abiflags.flags1;
15444
15445   return TRUE;
15446 }
15447
15448 /* Merge backend specific data from an object file to the output
15449    object file when linking.  */
15450
15451 bfd_boolean
15452 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
15453 {
15454   bfd *obfd = info->output_bfd;
15455   struct mips_elf_obj_tdata *out_tdata;
15456   struct mips_elf_obj_tdata *in_tdata;
15457   bfd_boolean null_input_bfd = TRUE;
15458   asection *sec;
15459   bfd_boolean ok;
15460
15461   /* Check if we have the same endianness.  */
15462   if (! _bfd_generic_verify_endian_match (ibfd, info))
15463     {
15464       _bfd_error_handler
15465         (_("%B: endianness incompatible with that of the selected emulation"),
15466          ibfd);
15467       return FALSE;
15468     }
15469
15470   if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
15471     return TRUE;
15472
15473   in_tdata = mips_elf_tdata (ibfd);
15474   out_tdata = mips_elf_tdata (obfd);
15475
15476   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
15477     {
15478       _bfd_error_handler
15479         (_("%B: ABI is incompatible with that of the selected emulation"),
15480          ibfd);
15481       return FALSE;
15482     }
15483
15484   /* Check to see if the input BFD actually contains any sections.  If not,
15485      then it has no attributes, and its flags may not have been initialized
15486      either, but it cannot actually cause any incompatibility.  */
15487   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
15488     {
15489       /* Ignore synthetic sections and empty .text, .data and .bss sections
15490          which are automatically generated by gas.  Also ignore fake
15491          (s)common sections, since merely defining a common symbol does
15492          not affect compatibility.  */
15493       if ((sec->flags & SEC_IS_COMMON) == 0
15494           && strcmp (sec->name, ".reginfo")
15495           && strcmp (sec->name, ".mdebug")
15496           && (sec->size != 0
15497               || (strcmp (sec->name, ".text")
15498                   && strcmp (sec->name, ".data")
15499                   && strcmp (sec->name, ".bss"))))
15500         {
15501           null_input_bfd = FALSE;
15502           break;
15503         }
15504     }
15505   if (null_input_bfd)
15506     return TRUE;
15507
15508   /* Populate abiflags using existing information.  */
15509   if (in_tdata->abiflags_valid)
15510     {
15511       obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15512       Elf_Internal_ABIFlags_v0 in_abiflags;
15513       Elf_Internal_ABIFlags_v0 abiflags;
15514
15515       /* Set up the FP ABI attribute from the abiflags if it is not already
15516          set.  */
15517       if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY)
15518         in_attr[Tag_GNU_MIPS_ABI_FP].i = in_tdata->abiflags.fp_abi;
15519
15520       infer_mips_abiflags (ibfd, &abiflags);
15521       in_abiflags = in_tdata->abiflags;
15522
15523       /* It is not possible to infer the correct ISA revision
15524          for R3 or R5 so drop down to R2 for the checks.  */
15525       if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5)
15526         in_abiflags.isa_rev = 2;
15527
15528       if (LEVEL_REV (in_abiflags.isa_level, in_abiflags.isa_rev)
15529           < LEVEL_REV (abiflags.isa_level, abiflags.isa_rev))
15530         _bfd_error_handler
15531           (_("%B: warning: Inconsistent ISA between e_flags and "
15532              ".MIPS.abiflags"), ibfd);
15533       if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
15534           && in_abiflags.fp_abi != abiflags.fp_abi)
15535         _bfd_error_handler
15536           (_("%B: warning: Inconsistent FP ABI between .gnu.attributes and "
15537              ".MIPS.abiflags"), ibfd);
15538       if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
15539         _bfd_error_handler
15540           (_("%B: warning: Inconsistent ASEs between e_flags and "
15541              ".MIPS.abiflags"), ibfd);
15542       /* The isa_ext is allowed to be an extension of what can be inferred
15543          from e_flags.  */
15544       if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags.isa_ext),
15545                                 bfd_mips_isa_ext_mach (in_abiflags.isa_ext)))
15546         _bfd_error_handler
15547           (_("%B: warning: Inconsistent ISA extensions between e_flags and "
15548              ".MIPS.abiflags"), ibfd);
15549       if (in_abiflags.flags2 != 0)
15550         _bfd_error_handler
15551           (_("%B: warning: Unexpected flag in the flags2 field of "
15552              ".MIPS.abiflags (0x%lx)"), ibfd,
15553            (unsigned long) in_abiflags.flags2);
15554     }
15555   else
15556     {
15557       infer_mips_abiflags (ibfd, &in_tdata->abiflags);
15558       in_tdata->abiflags_valid = TRUE;
15559     }
15560
15561   if (!out_tdata->abiflags_valid)
15562     {
15563       /* Copy input abiflags if output abiflags are not already valid.  */
15564       out_tdata->abiflags = in_tdata->abiflags;
15565       out_tdata->abiflags_valid = TRUE;
15566     }
15567
15568   if (! elf_flags_init (obfd))
15569     {
15570       elf_flags_init (obfd) = TRUE;
15571       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
15572       elf_elfheader (obfd)->e_ident[EI_CLASS]
15573         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
15574
15575       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
15576           && (bfd_get_arch_info (obfd)->the_default
15577               || mips_mach_extends_p (bfd_get_mach (obfd),
15578                                       bfd_get_mach (ibfd))))
15579         {
15580           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
15581                                    bfd_get_mach (ibfd)))
15582             return FALSE;
15583
15584           /* Update the ABI flags isa_level, isa_rev and isa_ext fields.  */
15585           update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15586         }
15587
15588       ok = TRUE;
15589     }
15590   else
15591     ok = mips_elf_merge_obj_e_flags (ibfd, info);
15592
15593   ok = mips_elf_merge_obj_attributes (ibfd, info) && ok;
15594
15595   ok = mips_elf_merge_obj_abiflags (ibfd, obfd) && ok;
15596
15597   if (!ok)
15598     {
15599       bfd_set_error (bfd_error_bad_value);
15600       return FALSE;
15601     }
15602
15603   return TRUE;
15604 }
15605
15606 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
15607
15608 bfd_boolean
15609 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
15610 {
15611   BFD_ASSERT (!elf_flags_init (abfd)
15612               || elf_elfheader (abfd)->e_flags == flags);
15613
15614   elf_elfheader (abfd)->e_flags = flags;
15615   elf_flags_init (abfd) = TRUE;
15616   return TRUE;
15617 }
15618
15619 char *
15620 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
15621 {
15622   switch (dtag)
15623     {
15624     default: return "";
15625     case DT_MIPS_RLD_VERSION:
15626       return "MIPS_RLD_VERSION";
15627     case DT_MIPS_TIME_STAMP:
15628       return "MIPS_TIME_STAMP";
15629     case DT_MIPS_ICHECKSUM:
15630       return "MIPS_ICHECKSUM";
15631     case DT_MIPS_IVERSION:
15632       return "MIPS_IVERSION";
15633     case DT_MIPS_FLAGS:
15634       return "MIPS_FLAGS";
15635     case DT_MIPS_BASE_ADDRESS:
15636       return "MIPS_BASE_ADDRESS";
15637     case DT_MIPS_MSYM:
15638       return "MIPS_MSYM";
15639     case DT_MIPS_CONFLICT:
15640       return "MIPS_CONFLICT";
15641     case DT_MIPS_LIBLIST:
15642       return "MIPS_LIBLIST";
15643     case DT_MIPS_LOCAL_GOTNO:
15644       return "MIPS_LOCAL_GOTNO";
15645     case DT_MIPS_CONFLICTNO:
15646       return "MIPS_CONFLICTNO";
15647     case DT_MIPS_LIBLISTNO:
15648       return "MIPS_LIBLISTNO";
15649     case DT_MIPS_SYMTABNO:
15650       return "MIPS_SYMTABNO";
15651     case DT_MIPS_UNREFEXTNO:
15652       return "MIPS_UNREFEXTNO";
15653     case DT_MIPS_GOTSYM:
15654       return "MIPS_GOTSYM";
15655     case DT_MIPS_HIPAGENO:
15656       return "MIPS_HIPAGENO";
15657     case DT_MIPS_RLD_MAP:
15658       return "MIPS_RLD_MAP";
15659     case DT_MIPS_RLD_MAP_REL:
15660       return "MIPS_RLD_MAP_REL";
15661     case DT_MIPS_DELTA_CLASS:
15662       return "MIPS_DELTA_CLASS";
15663     case DT_MIPS_DELTA_CLASS_NO:
15664       return "MIPS_DELTA_CLASS_NO";
15665     case DT_MIPS_DELTA_INSTANCE:
15666       return "MIPS_DELTA_INSTANCE";
15667     case DT_MIPS_DELTA_INSTANCE_NO:
15668       return "MIPS_DELTA_INSTANCE_NO";
15669     case DT_MIPS_DELTA_RELOC:
15670       return "MIPS_DELTA_RELOC";
15671     case DT_MIPS_DELTA_RELOC_NO:
15672       return "MIPS_DELTA_RELOC_NO";
15673     case DT_MIPS_DELTA_SYM:
15674       return "MIPS_DELTA_SYM";
15675     case DT_MIPS_DELTA_SYM_NO:
15676       return "MIPS_DELTA_SYM_NO";
15677     case DT_MIPS_DELTA_CLASSSYM:
15678       return "MIPS_DELTA_CLASSSYM";
15679     case DT_MIPS_DELTA_CLASSSYM_NO:
15680       return "MIPS_DELTA_CLASSSYM_NO";
15681     case DT_MIPS_CXX_FLAGS:
15682       return "MIPS_CXX_FLAGS";
15683     case DT_MIPS_PIXIE_INIT:
15684       return "MIPS_PIXIE_INIT";
15685     case DT_MIPS_SYMBOL_LIB:
15686       return "MIPS_SYMBOL_LIB";
15687     case DT_MIPS_LOCALPAGE_GOTIDX:
15688       return "MIPS_LOCALPAGE_GOTIDX";
15689     case DT_MIPS_LOCAL_GOTIDX:
15690       return "MIPS_LOCAL_GOTIDX";
15691     case DT_MIPS_HIDDEN_GOTIDX:
15692       return "MIPS_HIDDEN_GOTIDX";
15693     case DT_MIPS_PROTECTED_GOTIDX:
15694       return "MIPS_PROTECTED_GOT_IDX";
15695     case DT_MIPS_OPTIONS:
15696       return "MIPS_OPTIONS";
15697     case DT_MIPS_INTERFACE:
15698       return "MIPS_INTERFACE";
15699     case DT_MIPS_DYNSTR_ALIGN:
15700       return "DT_MIPS_DYNSTR_ALIGN";
15701     case DT_MIPS_INTERFACE_SIZE:
15702       return "DT_MIPS_INTERFACE_SIZE";
15703     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
15704       return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15705     case DT_MIPS_PERF_SUFFIX:
15706       return "DT_MIPS_PERF_SUFFIX";
15707     case DT_MIPS_COMPACT_SIZE:
15708       return "DT_MIPS_COMPACT_SIZE";
15709     case DT_MIPS_GP_VALUE:
15710       return "DT_MIPS_GP_VALUE";
15711     case DT_MIPS_AUX_DYNAMIC:
15712       return "DT_MIPS_AUX_DYNAMIC";
15713     case DT_MIPS_PLTGOT:
15714       return "DT_MIPS_PLTGOT";
15715     case DT_MIPS_RWPLT:
15716       return "DT_MIPS_RWPLT";
15717     }
15718 }
15719
15720 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15721    not known.  */
15722
15723 const char *
15724 _bfd_mips_fp_abi_string (int fp)
15725 {
15726   switch (fp)
15727     {
15728       /* These strings aren't translated because they're simply
15729          option lists.  */
15730     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15731       return "-mdouble-float";
15732
15733     case Val_GNU_MIPS_ABI_FP_SINGLE:
15734       return "-msingle-float";
15735
15736     case Val_GNU_MIPS_ABI_FP_SOFT:
15737       return "-msoft-float";
15738
15739     case Val_GNU_MIPS_ABI_FP_OLD_64:
15740       return _("-mips32r2 -mfp64 (12 callee-saved)");
15741
15742     case Val_GNU_MIPS_ABI_FP_XX:
15743       return "-mfpxx";
15744
15745     case Val_GNU_MIPS_ABI_FP_64:
15746       return "-mgp32 -mfp64";
15747
15748     case Val_GNU_MIPS_ABI_FP_64A:
15749       return "-mgp32 -mfp64 -mno-odd-spreg";
15750
15751     default:
15752       return 0;
15753     }
15754 }
15755
15756 static void
15757 print_mips_ases (FILE *file, unsigned int mask)
15758 {
15759   if (mask & AFL_ASE_DSP)
15760     fputs ("\n\tDSP ASE", file);
15761   if (mask & AFL_ASE_DSPR2)
15762     fputs ("\n\tDSP R2 ASE", file);
15763   if (mask & AFL_ASE_DSPR3)
15764     fputs ("\n\tDSP R3 ASE", file);
15765   if (mask & AFL_ASE_EVA)
15766     fputs ("\n\tEnhanced VA Scheme", file);
15767   if (mask & AFL_ASE_MCU)
15768     fputs ("\n\tMCU (MicroController) ASE", file);
15769   if (mask & AFL_ASE_MDMX)
15770     fputs ("\n\tMDMX ASE", file);
15771   if (mask & AFL_ASE_MIPS3D)
15772     fputs ("\n\tMIPS-3D ASE", file);
15773   if (mask & AFL_ASE_MT)
15774     fputs ("\n\tMT ASE", file);
15775   if (mask & AFL_ASE_SMARTMIPS)
15776     fputs ("\n\tSmartMIPS ASE", file);
15777   if (mask & AFL_ASE_VIRT)
15778     fputs ("\n\tVZ ASE", file);
15779   if (mask & AFL_ASE_MSA)
15780     fputs ("\n\tMSA ASE", file);
15781   if (mask & AFL_ASE_MIPS16)
15782     fputs ("\n\tMIPS16 ASE", file);
15783   if (mask & AFL_ASE_MICROMIPS)
15784     fputs ("\n\tMICROMIPS ASE", file);
15785   if (mask & AFL_ASE_XPA)
15786     fputs ("\n\tXPA ASE", file);
15787   if (mask == 0)
15788     fprintf (file, "\n\t%s", _("None"));
15789   else if ((mask & ~AFL_ASE_MASK) != 0)
15790     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15791 }
15792
15793 static void
15794 print_mips_isa_ext (FILE *file, unsigned int isa_ext)
15795 {
15796   switch (isa_ext)
15797     {
15798     case 0:
15799       fputs (_("None"), file);
15800       break;
15801     case AFL_EXT_XLR:
15802       fputs ("RMI XLR", file);
15803       break;
15804     case AFL_EXT_OCTEON3:
15805       fputs ("Cavium Networks Octeon3", file);
15806       break;
15807     case AFL_EXT_OCTEON2:
15808       fputs ("Cavium Networks Octeon2", file);
15809       break;
15810     case AFL_EXT_OCTEONP:
15811       fputs ("Cavium Networks OcteonP", file);
15812       break;
15813     case AFL_EXT_LOONGSON_3A:
15814       fputs ("Loongson 3A", file);
15815       break;
15816     case AFL_EXT_OCTEON:
15817       fputs ("Cavium Networks Octeon", file);
15818       break;
15819     case AFL_EXT_5900:
15820       fputs ("Toshiba R5900", file);
15821       break;
15822     case AFL_EXT_4650:
15823       fputs ("MIPS R4650", file);
15824       break;
15825     case AFL_EXT_4010:
15826       fputs ("LSI R4010", file);
15827       break;
15828     case AFL_EXT_4100:
15829       fputs ("NEC VR4100", file);
15830       break;
15831     case AFL_EXT_3900:
15832       fputs ("Toshiba R3900", file);
15833       break;
15834     case AFL_EXT_10000:
15835       fputs ("MIPS R10000", file);
15836       break;
15837     case AFL_EXT_SB1:
15838       fputs ("Broadcom SB-1", file);
15839       break;
15840     case AFL_EXT_4111:
15841       fputs ("NEC VR4111/VR4181", file);
15842       break;
15843     case AFL_EXT_4120:
15844       fputs ("NEC VR4120", file);
15845       break;
15846     case AFL_EXT_5400:
15847       fputs ("NEC VR5400", file);
15848       break;
15849     case AFL_EXT_5500:
15850       fputs ("NEC VR5500", file);
15851       break;
15852     case AFL_EXT_LOONGSON_2E:
15853       fputs ("ST Microelectronics Loongson 2E", file);
15854       break;
15855     case AFL_EXT_LOONGSON_2F:
15856       fputs ("ST Microelectronics Loongson 2F", file);
15857       break;
15858     default:
15859       fprintf (file, "%s (%d)", _("Unknown"), isa_ext);
15860       break;
15861     }
15862 }
15863
15864 static void
15865 print_mips_fp_abi_value (FILE *file, int val)
15866 {
15867   switch (val)
15868     {
15869     case Val_GNU_MIPS_ABI_FP_ANY:
15870       fprintf (file, _("Hard or soft float\n"));
15871       break;
15872     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15873       fprintf (file, _("Hard float (double precision)\n"));
15874       break;
15875     case Val_GNU_MIPS_ABI_FP_SINGLE:
15876       fprintf (file, _("Hard float (single precision)\n"));
15877       break;
15878     case Val_GNU_MIPS_ABI_FP_SOFT:
15879       fprintf (file, _("Soft float\n"));
15880       break;
15881     case Val_GNU_MIPS_ABI_FP_OLD_64:
15882       fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15883       break;
15884     case Val_GNU_MIPS_ABI_FP_XX:
15885       fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n"));
15886       break;
15887     case Val_GNU_MIPS_ABI_FP_64:
15888       fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
15889       break;
15890     case Val_GNU_MIPS_ABI_FP_64A:
15891       fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15892       break;
15893     default:
15894       fprintf (file, "??? (%d)\n", val);
15895       break;
15896     }
15897 }
15898
15899 static int
15900 get_mips_reg_size (int reg_size)
15901 {
15902   return (reg_size == AFL_REG_NONE) ? 0
15903          : (reg_size == AFL_REG_32) ? 32
15904          : (reg_size == AFL_REG_64) ? 64
15905          : (reg_size == AFL_REG_128) ? 128
15906          : -1;
15907 }
15908
15909 bfd_boolean
15910 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
15911 {
15912   FILE *file = ptr;
15913
15914   BFD_ASSERT (abfd != NULL && ptr != NULL);
15915
15916   /* Print normal ELF private data.  */
15917   _bfd_elf_print_private_bfd_data (abfd, ptr);
15918
15919   /* xgettext:c-format */
15920   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
15921
15922   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
15923     fprintf (file, _(" [abi=O32]"));
15924   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
15925     fprintf (file, _(" [abi=O64]"));
15926   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
15927     fprintf (file, _(" [abi=EABI32]"));
15928   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
15929     fprintf (file, _(" [abi=EABI64]"));
15930   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
15931     fprintf (file, _(" [abi unknown]"));
15932   else if (ABI_N32_P (abfd))
15933     fprintf (file, _(" [abi=N32]"));
15934   else if (ABI_64_P (abfd))
15935     fprintf (file, _(" [abi=64]"));
15936   else
15937     fprintf (file, _(" [no abi set]"));
15938
15939   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
15940     fprintf (file, " [mips1]");
15941   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
15942     fprintf (file, " [mips2]");
15943   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
15944     fprintf (file, " [mips3]");
15945   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
15946     fprintf (file, " [mips4]");
15947   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
15948     fprintf (file, " [mips5]");
15949   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
15950     fprintf (file, " [mips32]");
15951   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
15952     fprintf (file, " [mips64]");
15953   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
15954     fprintf (file, " [mips32r2]");
15955   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
15956     fprintf (file, " [mips64r2]");
15957   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6)
15958     fprintf (file, " [mips32r6]");
15959   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
15960     fprintf (file, " [mips64r6]");
15961   else
15962     fprintf (file, _(" [unknown ISA]"));
15963
15964   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
15965     fprintf (file, " [mdmx]");
15966
15967   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
15968     fprintf (file, " [mips16]");
15969
15970   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
15971     fprintf (file, " [micromips]");
15972
15973   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008)
15974     fprintf (file, " [nan2008]");
15975
15976   if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64)
15977     fprintf (file, " [old fp64]");
15978
15979   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
15980     fprintf (file, " [32bitmode]");
15981   else
15982     fprintf (file, _(" [not 32bitmode]"));
15983
15984   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
15985     fprintf (file, " [noreorder]");
15986
15987   if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
15988     fprintf (file, " [PIC]");
15989
15990   if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
15991     fprintf (file, " [CPIC]");
15992
15993   if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
15994     fprintf (file, " [XGOT]");
15995
15996   if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
15997     fprintf (file, " [UCODE]");
15998
15999   fputc ('\n', file);
16000
16001   if (mips_elf_tdata (abfd)->abiflags_valid)
16002     {
16003       Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags;
16004       fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version);
16005       fprintf (file, "\nISA: MIPS%d", abiflags->isa_level);
16006       if (abiflags->isa_rev > 1)
16007         fprintf (file, "r%d", abiflags->isa_rev);
16008       fprintf (file, "\nGPR size: %d",
16009                get_mips_reg_size (abiflags->gpr_size));
16010       fprintf (file, "\nCPR1 size: %d",
16011                get_mips_reg_size (abiflags->cpr1_size));
16012       fprintf (file, "\nCPR2 size: %d",
16013                get_mips_reg_size (abiflags->cpr2_size));
16014       fputs ("\nFP ABI: ", file);
16015       print_mips_fp_abi_value (file, abiflags->fp_abi);
16016       fputs ("ISA Extension: ", file);
16017       print_mips_isa_ext (file, abiflags->isa_ext);
16018       fputs ("\nASEs:", file);
16019       print_mips_ases (file, abiflags->ases);
16020       fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1);
16021       fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2);
16022       fputc ('\n', file);
16023     }
16024
16025   return TRUE;
16026 }
16027
16028 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
16029 {
16030   { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16031   { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16032   { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
16033   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16034   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16035   { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
16036   { NULL,                     0,  0, 0,              0 }
16037 };
16038
16039 /* Merge non visibility st_other attributes.  Ensure that the
16040    STO_OPTIONAL flag is copied into h->other, even if this is not a
16041    definiton of the symbol.  */
16042 void
16043 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
16044                                       const Elf_Internal_Sym *isym,
16045                                       bfd_boolean definition,
16046                                       bfd_boolean dynamic ATTRIBUTE_UNUSED)
16047 {
16048   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
16049     {
16050       unsigned char other;
16051
16052       other = (definition ? isym->st_other : h->other);
16053       other &= ~ELF_ST_VISIBILITY (-1);
16054       h->other = other | ELF_ST_VISIBILITY (h->other);
16055     }
16056
16057   if (!definition
16058       && ELF_MIPS_IS_OPTIONAL (isym->st_other))
16059     h->other |= STO_OPTIONAL;
16060 }
16061
16062 /* Decide whether an undefined symbol is special and can be ignored.
16063    This is the case for OPTIONAL symbols on IRIX.  */
16064 bfd_boolean
16065 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
16066 {
16067   return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
16068 }
16069
16070 bfd_boolean
16071 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
16072 {
16073   return (sym->st_shndx == SHN_COMMON
16074           || sym->st_shndx == SHN_MIPS_ACOMMON
16075           || sym->st_shndx == SHN_MIPS_SCOMMON);
16076 }
16077
16078 /* Return address for Ith PLT stub in section PLT, for relocation REL
16079    or (bfd_vma) -1 if it should not be included.  */
16080
16081 bfd_vma
16082 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
16083                            const arelent *rel ATTRIBUTE_UNUSED)
16084 {
16085   return (plt->vma
16086           + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
16087           + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
16088 }
16089
16090 /* Build a table of synthetic symbols to represent the PLT.  As with MIPS16
16091    and microMIPS PLT slots we may have a many-to-one mapping between .plt
16092    and .got.plt and also the slots may be of a different size each we walk
16093    the PLT manually fetching instructions and matching them against known
16094    patterns.  To make things easier standard MIPS slots, if any, always come
16095    first.  As we don't create proper ELF symbols we use the UDATA.I member
16096    of ASYMBOL to carry ISA annotation.  The encoding used is the same as
16097    with the ST_OTHER member of the ELF symbol.  */
16098
16099 long
16100 _bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
16101                                     long symcount ATTRIBUTE_UNUSED,
16102                                     asymbol **syms ATTRIBUTE_UNUSED,
16103                                     long dynsymcount, asymbol **dynsyms,
16104                                     asymbol **ret)
16105 {
16106   static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_";
16107   static const char microsuffix[] = "@micromipsplt";
16108   static const char m16suffix[] = "@mips16plt";
16109   static const char mipssuffix[] = "@plt";
16110
16111   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
16112   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
16113   bfd_boolean micromips_p = MICROMIPS_P (abfd);
16114   Elf_Internal_Shdr *hdr;
16115   bfd_byte *plt_data;
16116   bfd_vma plt_offset;
16117   unsigned int other;
16118   bfd_vma entry_size;
16119   bfd_vma plt0_size;
16120   asection *relplt;
16121   bfd_vma opcode;
16122   asection *plt;
16123   asymbol *send;
16124   size_t size;
16125   char *names;
16126   long counti;
16127   arelent *p;
16128   asymbol *s;
16129   char *nend;
16130   long count;
16131   long pi;
16132   long i;
16133   long n;
16134
16135   *ret = NULL;
16136
16137   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0)
16138     return 0;
16139
16140   relplt = bfd_get_section_by_name (abfd, ".rel.plt");
16141   if (relplt == NULL)
16142     return 0;
16143
16144   hdr = &elf_section_data (relplt)->this_hdr;
16145   if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL)
16146     return 0;
16147
16148   plt = bfd_get_section_by_name (abfd, ".plt");
16149   if (plt == NULL)
16150     return 0;
16151
16152   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
16153   if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
16154     return -1;
16155   p = relplt->relocation;
16156
16157   /* Calculating the exact amount of space required for symbols would
16158      require two passes over the PLT, so just pessimise assuming two
16159      PLT slots per relocation.  */
16160   count = relplt->size / hdr->sh_entsize;
16161   counti = count * bed->s->int_rels_per_ext_rel;
16162   size = 2 * count * sizeof (asymbol);
16163   size += count * (sizeof (mipssuffix) +
16164                    (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix)));
16165   for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel)
16166     size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name);
16167
16168   /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too.  */
16169   size += sizeof (asymbol) + sizeof (pltname);
16170
16171   if (!bfd_malloc_and_get_section (abfd, plt, &plt_data))
16172     return -1;
16173
16174   if (plt->size < 16)
16175     return -1;
16176
16177   s = *ret = bfd_malloc (size);
16178   if (s == NULL)
16179     return -1;
16180   send = s + 2 * count + 1;
16181
16182   names = (char *) send;
16183   nend = (char *) s + size;
16184   n = 0;
16185
16186   opcode = bfd_get_micromips_32 (abfd, plt_data + 12);
16187   if (opcode == 0x3302fffe)
16188     {
16189       if (!micromips_p)
16190         return -1;
16191       plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
16192       other = STO_MICROMIPS;
16193     }
16194   else if (opcode == 0x0398c1d0)
16195     {
16196       if (!micromips_p)
16197         return -1;
16198       plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
16199       other = STO_MICROMIPS;
16200     }
16201   else
16202     {
16203       plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
16204       other = 0;
16205     }
16206
16207   s->the_bfd = abfd;
16208   s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL;
16209   s->section = plt;
16210   s->value = 0;
16211   s->name = names;
16212   s->udata.i = other;
16213   memcpy (names, pltname, sizeof (pltname));
16214   names += sizeof (pltname);
16215   ++s, ++n;
16216
16217   pi = 0;
16218   for (plt_offset = plt0_size;
16219        plt_offset + 8 <= plt->size && s < send;
16220        plt_offset += entry_size)
16221     {
16222       bfd_vma gotplt_addr;
16223       const char *suffix;
16224       bfd_vma gotplt_hi;
16225       bfd_vma gotplt_lo;
16226       size_t suffixlen;
16227
16228       opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4);
16229
16230       /* Check if the second word matches the expected MIPS16 instruction.  */
16231       if (opcode == 0x651aeb00)
16232         {
16233           if (micromips_p)
16234             return -1;
16235           /* Truncated table???  */
16236           if (plt_offset + 16 > plt->size)
16237             break;
16238           gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12);
16239           entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
16240           suffixlen = sizeof (m16suffix);
16241           suffix = m16suffix;
16242           other = STO_MIPS16;
16243         }
16244       /* Likewise the expected microMIPS instruction (no insn32 mode).  */
16245       else if (opcode == 0xff220000)
16246         {
16247           if (!micromips_p)
16248             return -1;
16249           gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f;
16250           gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16251           gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18;
16252           gotplt_lo <<= 2;
16253           gotplt_addr = gotplt_hi + gotplt_lo;
16254           gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3;
16255           entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
16256           suffixlen = sizeof (microsuffix);
16257           suffix = microsuffix;
16258           other = STO_MICROMIPS;
16259         }
16260       /* Likewise the expected microMIPS instruction (insn32 mode).  */
16261       else if ((opcode & 0xffff0000) == 0xff2f0000)
16262         {
16263           gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16264           gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff;
16265           gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16266           gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16267           gotplt_addr = gotplt_hi + gotplt_lo;
16268           entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
16269           suffixlen = sizeof (microsuffix);
16270           suffix = microsuffix;
16271           other = STO_MICROMIPS;
16272         }
16273       /* Otherwise assume standard MIPS code.  */
16274       else
16275         {
16276           gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff;
16277           gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff;
16278           gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16279           gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16280           gotplt_addr = gotplt_hi + gotplt_lo;
16281           entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
16282           suffixlen = sizeof (mipssuffix);
16283           suffix = mipssuffix;
16284           other = 0;
16285         }
16286       /* Truncated table???  */
16287       if (plt_offset + entry_size > plt->size)
16288         break;
16289
16290       for (i = 0;
16291            i < count && p[pi].address != gotplt_addr;
16292            i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti);
16293
16294       if (i < count)
16295         {
16296           size_t namelen;
16297           size_t len;
16298
16299           *s = **p[pi].sym_ptr_ptr;
16300           /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
16301              we are defining a symbol, ensure one of them is set.  */
16302           if ((s->flags & BSF_LOCAL) == 0)
16303             s->flags |= BSF_GLOBAL;
16304           s->flags |= BSF_SYNTHETIC;
16305           s->section = plt;
16306           s->value = plt_offset;
16307           s->name = names;
16308           s->udata.i = other;
16309
16310           len = strlen ((*p[pi].sym_ptr_ptr)->name);
16311           namelen = len + suffixlen;
16312           if (names + namelen > nend)
16313             break;
16314
16315           memcpy (names, (*p[pi].sym_ptr_ptr)->name, len);
16316           names += len;
16317           memcpy (names, suffix, suffixlen);
16318           names += suffixlen;
16319
16320           ++s, ++n;
16321           pi = (pi + bed->s->int_rels_per_ext_rel) % counti;
16322         }
16323     }
16324
16325   free (plt_data);
16326
16327   return n;
16328 }
16329
16330 /* Return the ABI flags associated with ABFD if available.  */
16331
16332 Elf_Internal_ABIFlags_v0 *
16333 bfd_mips_elf_get_abiflags (bfd *abfd)
16334 {
16335   struct mips_elf_obj_tdata *tdata = mips_elf_tdata (abfd);
16336
16337   return tdata->abiflags_valid ? &tdata->abiflags : NULL;
16338 }
16339
16340 void
16341 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
16342 {
16343   struct mips_elf_link_hash_table *htab;
16344   Elf_Internal_Ehdr *i_ehdrp;
16345
16346   i_ehdrp = elf_elfheader (abfd);
16347   if (link_info)
16348     {
16349       htab = mips_elf_hash_table (link_info);
16350       BFD_ASSERT (htab != NULL);
16351
16352       if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
16353         i_ehdrp->e_ident[EI_ABIVERSION] = 1;
16354     }
16355
16356   _bfd_elf_post_process_headers (abfd, link_info);
16357
16358   if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64
16359       || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A)
16360     i_ehdrp->e_ident[EI_ABIVERSION] = 3;
16361
16362   if (elf_stack_flags (abfd) && !(elf_stack_flags (abfd) & PF_X))
16363     i_ehdrp->e_ident[EI_ABIVERSION] = 5;
16364 }
16365
16366 int
16367 _bfd_mips_elf_compact_eh_encoding (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16368 {
16369   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
16370 }
16371
16372 /* Return the opcode for can't unwind.  */
16373
16374 int
16375 _bfd_mips_elf_cant_unwind_opcode (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16376 {
16377   return COMPACT_EH_CANT_UNWIND_OPCODE;
16378 }