Home | History | Annotate | Download | only in bfd
      1 /* MIPS-specific support for ELF
      2    Copyright (C) 1993-2014 Free Software Foundation, Inc.
      3 
      4    Most of the information added by Ian Lance Taylor, Cygnus Support,
      5    <ian (at) cygnus.com>.
      6    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
      7    <mark (at) codesourcery.com>
      8    Traditional MIPS targets support added by Koundinya.K, Dansk Data
      9    Elektronik & Operations Research Group. <kk (at) 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 
     40 /* Get the ECOFF swapping routines.  */
     41 #include "coff/sym.h"
     42 #include "coff/symconst.h"
     43 #include "coff/ecoff.h"
     44 #include "coff/mips.h"
     45 
     46 #include "hashtab.h"
     47 
     48 /* Types of TLS GOT entry.  */
     49 enum mips_got_tls_type {
     50   GOT_TLS_NONE,
     51   GOT_TLS_GD,
     52   GOT_TLS_LDM,
     53   GOT_TLS_IE
     54 };
     55 
     56 /* This structure is used to hold information about one GOT entry.
     57    There are four types of entry:
     58 
     59       (1) an absolute address
     60 	    requires: abfd == NULL
     61 	    fields: d.address
     62 
     63       (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd
     64 	    requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM
     65 	    fields: abfd, symndx, d.addend, tls_type
     66 
     67       (3) a SYMBOL address, where SYMBOL is not local to an input bfd
     68 	    requires: abfd != NULL, symndx == -1
     69 	    fields: d.h, tls_type
     70 
     71       (4) a TLS LDM slot
     72 	    requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM
     73 	    fields: none; there's only one of these per GOT.  */
     74 struct mips_got_entry
     75 {
     76   /* One input bfd that needs the GOT entry.  */
     77   bfd *abfd;
     78   /* The index of the symbol, as stored in the relocation r_info, if
     79      we have a local symbol; -1 otherwise.  */
     80   long symndx;
     81   union
     82   {
     83     /* If abfd == NULL, an address that must be stored in the got.  */
     84     bfd_vma address;
     85     /* If abfd != NULL && symndx != -1, the addend of the relocation
     86        that should be added to the symbol value.  */
     87     bfd_vma addend;
     88     /* If abfd != NULL && symndx == -1, the hash table entry
     89        corresponding to a symbol in the GOT.  The symbol's entry
     90        is in the local area if h->global_got_area is GGA_NONE,
     91        otherwise it is in the global area.  */
     92     struct mips_elf_link_hash_entry *h;
     93   } d;
     94 
     95   /* The TLS type of this GOT entry.  An LDM GOT entry will be a local
     96      symbol entry with r_symndx == 0.  */
     97   unsigned char tls_type;
     98 
     99   /* True if we have filled in the GOT contents for a TLS entry,
    100      and created the associated relocations.  */
    101   unsigned char tls_initialized;
    102 
    103   /* The offset from the beginning of the .got section to the entry
    104      corresponding to this symbol+addend.  If it's a global symbol
    105      whose offset is yet to be decided, it's going to be -1.  */
    106   long gotidx;
    107 };
    108 
    109 /* This structure represents a GOT page reference from an input bfd.
    110    Each instance represents a symbol + ADDEND, where the representation
    111    of the symbol depends on whether it is local to the input bfd.
    112    If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD.
    113    Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry.
    114 
    115    Page references with SYMNDX >= 0 always become page references
    116    in the output.  Page references with SYMNDX < 0 only become page
    117    references if the symbol binds locally; in other cases, the page
    118    reference decays to a global GOT reference.  */
    119 struct mips_got_page_ref
    120 {
    121   long symndx;
    122   union
    123   {
    124     struct mips_elf_link_hash_entry *h;
    125     bfd *abfd;
    126   } u;
    127   bfd_vma addend;
    128 };
    129 
    130 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
    131    The structures form a non-overlapping list that is sorted by increasing
    132    MIN_ADDEND.  */
    133 struct mips_got_page_range
    134 {
    135   struct mips_got_page_range *next;
    136   bfd_signed_vma min_addend;
    137   bfd_signed_vma max_addend;
    138 };
    139 
    140 /* This structure describes the range of addends that are applied to page
    141    relocations against a given section.  */
    142 struct mips_got_page_entry
    143 {
    144   /* The section that these entries are based on.  */
    145   asection *sec;
    146   /* The ranges for this page entry.  */
    147   struct mips_got_page_range *ranges;
    148   /* The maximum number of page entries needed for RANGES.  */
    149   bfd_vma num_pages;
    150 };
    151 
    152 /* This structure is used to hold .got information when linking.  */
    153 
    154 struct mips_got_info
    155 {
    156   /* The number of global .got entries.  */
    157   unsigned int global_gotno;
    158   /* The number of global .got entries that are in the GGA_RELOC_ONLY area.  */
    159   unsigned int reloc_only_gotno;
    160   /* The number of .got slots used for TLS.  */
    161   unsigned int tls_gotno;
    162   /* The first unused TLS .got entry.  Used only during
    163      mips_elf_initialize_tls_index.  */
    164   unsigned int tls_assigned_gotno;
    165   /* The number of local .got entries, eventually including page entries.  */
    166   unsigned int local_gotno;
    167   /* The maximum number of page entries needed.  */
    168   unsigned int page_gotno;
    169   /* The number of relocations needed for the GOT entries.  */
    170   unsigned int relocs;
    171   /* The first unused local .got entry.  */
    172   unsigned int assigned_low_gotno;
    173   /* The last unused local .got entry.  */
    174   unsigned int assigned_high_gotno;
    175   /* A hash table holding members of the got.  */
    176   struct htab *got_entries;
    177   /* A hash table holding mips_got_page_ref structures.  */
    178   struct htab *got_page_refs;
    179   /* A hash table of mips_got_page_entry structures.  */
    180   struct htab *got_page_entries;
    181   /* In multi-got links, a pointer to the next got (err, rather, most
    182      of the time, it points to the previous got).  */
    183   struct mips_got_info *next;
    184 };
    185 
    186 /* Structure passed when merging bfds' gots.  */
    187 
    188 struct mips_elf_got_per_bfd_arg
    189 {
    190   /* The output bfd.  */
    191   bfd *obfd;
    192   /* The link information.  */
    193   struct bfd_link_info *info;
    194   /* A pointer to the primary got, i.e., the one that's going to get
    195      the implicit relocations from DT_MIPS_LOCAL_GOTNO and
    196      DT_MIPS_GOTSYM.  */
    197   struct mips_got_info *primary;
    198   /* A non-primary got we're trying to merge with other input bfd's
    199      gots.  */
    200   struct mips_got_info *current;
    201   /* The maximum number of got entries that can be addressed with a
    202      16-bit offset.  */
    203   unsigned int max_count;
    204   /* The maximum number of page entries needed by each got.  */
    205   unsigned int max_pages;
    206   /* The total number of global entries which will live in the
    207      primary got and be automatically relocated.  This includes
    208      those not referenced by the primary GOT but included in
    209      the "master" GOT.  */
    210   unsigned int global_count;
    211 };
    212 
    213 /* A structure used to pass information to htab_traverse callbacks
    214    when laying out the GOT.  */
    215 
    216 struct mips_elf_traverse_got_arg
    217 {
    218   struct bfd_link_info *info;
    219   struct mips_got_info *g;
    220   int value;
    221 };
    222 
    223 struct _mips_elf_section_data
    224 {
    225   struct bfd_elf_section_data elf;
    226   union
    227   {
    228     bfd_byte *tdata;
    229   } u;
    230 };
    231 
    232 #define mips_elf_section_data(sec) \
    233   ((struct _mips_elf_section_data *) elf_section_data (sec))
    234 
    235 #define is_mips_elf(bfd)				\
    236   (bfd_get_flavour (bfd) == bfd_target_elf_flavour	\
    237    && elf_tdata (bfd) != NULL				\
    238    && elf_object_id (bfd) == MIPS_ELF_DATA)
    239 
    240 /* The ABI says that every symbol used by dynamic relocations must have
    241    a global GOT entry.  Among other things, this provides the dynamic
    242    linker with a free, directly-indexed cache.  The GOT can therefore
    243    contain symbols that are not referenced by GOT relocations themselves
    244    (in other words, it may have symbols that are not referenced by things
    245    like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
    246 
    247    GOT relocations are less likely to overflow if we put the associated
    248    GOT entries towards the beginning.  We therefore divide the global
    249    GOT entries into two areas: "normal" and "reloc-only".  Entries in
    250    the first area can be used for both dynamic relocations and GP-relative
    251    accesses, while those in the "reloc-only" area are for dynamic
    252    relocations only.
    253 
    254    These GGA_* ("Global GOT Area") values are organised so that lower
    255    values are more general than higher values.  Also, non-GGA_NONE
    256    values are ordered by the position of the area in the GOT.  */
    257 #define GGA_NORMAL 0
    258 #define GGA_RELOC_ONLY 1
    259 #define GGA_NONE 2
    260 
    261 /* Information about a non-PIC interface to a PIC function.  There are
    262    two ways of creating these interfaces.  The first is to add:
    263 
    264 	lui	$25,%hi(func)
    265 	addiu	$25,$25,%lo(func)
    266 
    267    immediately before a PIC function "func".  The second is to add:
    268 
    269 	lui	$25,%hi(func)
    270 	j	func
    271 	addiu	$25,$25,%lo(func)
    272 
    273    to a separate trampoline section.
    274 
    275    Stubs of the first kind go in a new section immediately before the
    276    target function.  Stubs of the second kind go in a single section
    277    pointed to by the hash table's "strampoline" field.  */
    278 struct mips_elf_la25_stub {
    279   /* The generated section that contains this stub.  */
    280   asection *stub_section;
    281 
    282   /* The offset of the stub from the start of STUB_SECTION.  */
    283   bfd_vma offset;
    284 
    285   /* One symbol for the original function.  Its location is available
    286      in H->root.root.u.def.  */
    287   struct mips_elf_link_hash_entry *h;
    288 };
    289 
    290 /* Macros for populating a mips_elf_la25_stub.  */
    291 
    292 #define LA25_LUI(VAL) (0x3c190000 | (VAL))	/* lui t9,VAL */
    293 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
    294 #define LA25_ADDIU(VAL) (0x27390000 | (VAL))	/* addiu t9,t9,VAL */
    295 #define LA25_LUI_MICROMIPS(VAL)						\
    296   (0x41b90000 | (VAL))				/* lui t9,VAL */
    297 #define LA25_J_MICROMIPS(VAL)						\
    298   (0xd4000000 | (((VAL) >> 1) & 0x3ffffff))	/* j VAL */
    299 #define LA25_ADDIU_MICROMIPS(VAL)					\
    300   (0x33390000 | (VAL))				/* addiu t9,t9,VAL */
    301 
    302 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
    303    the dynamic symbols.  */
    304 
    305 struct mips_elf_hash_sort_data
    306 {
    307   /* The symbol in the global GOT with the lowest dynamic symbol table
    308      index.  */
    309   struct elf_link_hash_entry *low;
    310   /* The least dynamic symbol table index corresponding to a non-TLS
    311      symbol with a GOT entry.  */
    312   long min_got_dynindx;
    313   /* The greatest dynamic symbol table index corresponding to a symbol
    314      with a GOT entry that is not referenced (e.g., a dynamic symbol
    315      with dynamic relocations pointing to it from non-primary GOTs).  */
    316   long max_unref_got_dynindx;
    317   /* The greatest dynamic symbol table index not corresponding to a
    318      symbol without a GOT entry.  */
    319   long max_non_got_dynindx;
    320 };
    321 
    322 /* We make up to two PLT entries if needed, one for standard MIPS code
    323    and one for compressed code, either a MIPS16 or microMIPS one.  We
    324    keep a separate record of traditional lazy-binding stubs, for easier
    325    processing.  */
    326 
    327 struct plt_entry
    328 {
    329   /* Traditional SVR4 stub offset, or -1 if none.  */
    330   bfd_vma stub_offset;
    331 
    332   /* Standard PLT entry offset, or -1 if none.  */
    333   bfd_vma mips_offset;
    334 
    335   /* Compressed PLT entry offset, or -1 if none.  */
    336   bfd_vma comp_offset;
    337 
    338   /* The corresponding .got.plt index, or -1 if none.  */
    339   bfd_vma gotplt_index;
    340 
    341   /* Whether we need a standard PLT entry.  */
    342   unsigned int need_mips : 1;
    343 
    344   /* Whether we need a compressed PLT entry.  */
    345   unsigned int need_comp : 1;
    346 };
    347 
    348 /* The MIPS ELF linker needs additional information for each symbol in
    349    the global hash table.  */
    350 
    351 struct mips_elf_link_hash_entry
    352 {
    353   struct elf_link_hash_entry root;
    354 
    355   /* External symbol information.  */
    356   EXTR esym;
    357 
    358   /* The la25 stub we have created for ths symbol, if any.  */
    359   struct mips_elf_la25_stub *la25_stub;
    360 
    361   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
    362      this symbol.  */
    363   unsigned int possibly_dynamic_relocs;
    364 
    365   /* If there is a stub that 32 bit functions should use to call this
    366      16 bit function, this points to the section containing the stub.  */
    367   asection *fn_stub;
    368 
    369   /* If there is a stub that 16 bit functions should use to call this
    370      32 bit function, this points to the section containing the stub.  */
    371   asection *call_stub;
    372 
    373   /* This is like the call_stub field, but it is used if the function
    374      being called returns a floating point value.  */
    375   asection *call_fp_stub;
    376 
    377   /* The highest GGA_* value that satisfies all references to this symbol.  */
    378   unsigned int global_got_area : 2;
    379 
    380   /* True if all GOT relocations against this symbol are for calls.  This is
    381      a looser condition than no_fn_stub below, because there may be other
    382      non-call non-GOT relocations against the symbol.  */
    383   unsigned int got_only_for_calls : 1;
    384 
    385   /* True if one of the relocations described by possibly_dynamic_relocs
    386      is against a readonly section.  */
    387   unsigned int readonly_reloc : 1;
    388 
    389   /* True if there is a relocation against this symbol that must be
    390      resolved by the static linker (in other words, if the relocation
    391      cannot possibly be made dynamic).  */
    392   unsigned int has_static_relocs : 1;
    393 
    394   /* True if we must not create a .MIPS.stubs entry for this symbol.
    395      This is set, for example, if there are relocations related to
    396      taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
    397      See "MIPS ABI Supplement, 3rd Edition", p. 4-20.  */
    398   unsigned int no_fn_stub : 1;
    399 
    400   /* Whether we need the fn_stub; this is true if this symbol appears
    401      in any relocs other than a 16 bit call.  */
    402   unsigned int need_fn_stub : 1;
    403 
    404   /* True if this symbol is referenced by branch relocations from
    405      any non-PIC input file.  This is used to determine whether an
    406      la25 stub is required.  */
    407   unsigned int has_nonpic_branches : 1;
    408 
    409   /* Does this symbol need a traditional MIPS lazy-binding stub
    410      (as opposed to a PLT entry)?  */
    411   unsigned int needs_lazy_stub : 1;
    412 
    413   /* Does this symbol resolve to a PLT entry?  */
    414   unsigned int use_plt_entry : 1;
    415 };
    416 
    417 /* MIPS ELF linker hash table.  */
    418 
    419 struct mips_elf_link_hash_table
    420 {
    421   struct elf_link_hash_table root;
    422 
    423   /* The number of .rtproc entries.  */
    424   bfd_size_type procedure_count;
    425 
    426   /* The size of the .compact_rel section (if SGI_COMPAT).  */
    427   bfd_size_type compact_rel_size;
    428 
    429   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
    430      is set to the address of __rld_obj_head as in IRIX5 and IRIX6.  */
    431   bfd_boolean use_rld_obj_head;
    432 
    433   /* The  __rld_map or __rld_obj_head symbol. */
    434   struct elf_link_hash_entry *rld_symbol;
    435 
    436   /* This is set if we see any mips16 stub sections.  */
    437   bfd_boolean mips16_stubs_seen;
    438 
    439   /* True if we can generate copy relocs and PLTs.  */
    440   bfd_boolean use_plts_and_copy_relocs;
    441 
    442   /* True if we can only use 32-bit microMIPS instructions.  */
    443   bfd_boolean insn32;
    444 
    445   /* True if we are targetting R6 compact branches.  */
    446   bfd_boolean compact_branches;
    447 
    448   /* True if we're generating code for VxWorks.  */
    449   bfd_boolean is_vxworks;
    450 
    451   /* True if we already reported the small-data section overflow.  */
    452   bfd_boolean small_data_overflow_reported;
    453 
    454   /* Shortcuts to some dynamic sections, or NULL if they are not
    455      being used.  */
    456   asection *srelbss;
    457   asection *sdynbss;
    458   asection *srelplt;
    459   asection *srelplt2;
    460   asection *sgotplt;
    461   asection *splt;
    462   asection *sstubs;
    463   asection *sgot;
    464 
    465   /* The master GOT information.  */
    466   struct mips_got_info *got_info;
    467 
    468   /* The global symbol in the GOT with the lowest index in the dynamic
    469      symbol table.  */
    470   struct elf_link_hash_entry *global_gotsym;
    471 
    472   /* The size of the PLT header in bytes.  */
    473   bfd_vma plt_header_size;
    474 
    475   /* The size of a standard PLT entry in bytes.  */
    476   bfd_vma plt_mips_entry_size;
    477 
    478   /* The size of a compressed PLT entry in bytes.  */
    479   bfd_vma plt_comp_entry_size;
    480 
    481   /* The offset of the next standard PLT entry to create.  */
    482   bfd_vma plt_mips_offset;
    483 
    484   /* The offset of the next compressed PLT entry to create.  */
    485   bfd_vma plt_comp_offset;
    486 
    487   /* The index of the next .got.plt entry to create.  */
    488   bfd_vma plt_got_index;
    489 
    490   /* The number of functions that need a lazy-binding stub.  */
    491   bfd_vma lazy_stub_count;
    492 
    493   /* The size of a function stub entry in bytes.  */
    494   bfd_vma function_stub_size;
    495 
    496   /* The number of reserved entries at the beginning of the GOT.  */
    497   unsigned int reserved_gotno;
    498 
    499   /* The section used for mips_elf_la25_stub trampolines.
    500      See the comment above that structure for details.  */
    501   asection *strampoline;
    502 
    503   /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
    504      pairs.  */
    505   htab_t la25_stubs;
    506 
    507   /* A function FN (NAME, IS, OS) that creates a new input section
    508      called NAME and links it to output section OS.  If IS is nonnull,
    509      the new section should go immediately before it, otherwise it
    510      should go at the (current) beginning of OS.
    511 
    512      The function returns the new section on success, otherwise it
    513      returns null.  */
    514   asection *(*add_stub_section) (const char *, asection *, asection *);
    515 
    516   /* Small local sym cache.  */
    517   struct sym_cache sym_cache;
    518 
    519   /* Is the PLT header compressed?  */
    520   unsigned int plt_header_is_comp : 1;
    521 };
    522 
    523 /* Get the MIPS ELF linker hash table from a link_info structure.  */
    524 
    525 #define mips_elf_hash_table(p) \
    526   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
    527   == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
    528 
    529 /* A structure used to communicate with htab_traverse callbacks.  */
    530 struct mips_htab_traverse_info
    531 {
    532   /* The usual link-wide information.  */
    533   struct bfd_link_info *info;
    534   bfd *output_bfd;
    535 
    536   /* Starts off FALSE and is set to TRUE if the link should be aborted.  */
    537   bfd_boolean error;
    538 };
    539 
    540 /* MIPS ELF private object data.  */
    541 
    542 struct mips_elf_obj_tdata
    543 {
    544   /* Generic ELF private object data.  */
    545   struct elf_obj_tdata root;
    546 
    547   /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output.  */
    548   bfd *abi_fp_bfd;
    549 
    550   /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output.  */
    551   bfd *abi_msa_bfd;
    552 
    553   /* The abiflags for this object.  */
    554   Elf_Internal_ABIFlags_v0 abiflags;
    555   bfd_boolean abiflags_valid;
    556 
    557   /* The GOT requirements of input bfds.  */
    558   struct mips_got_info *got;
    559 
    560   /* Used by _bfd_mips_elf_find_nearest_line.  The structure could be
    561      included directly in this one, but there's no point to wasting
    562      the memory just for the infrequently called find_nearest_line.  */
    563   struct mips_elf_find_line *find_line_info;
    564 
    565   /* An array of stub sections indexed by symbol number.  */
    566   asection **local_stubs;
    567   asection **local_call_stubs;
    568 
    569   /* The Irix 5 support uses two virtual sections, which represent
    570      text/data symbols defined in dynamic objects.  */
    571   asymbol *elf_data_symbol;
    572   asymbol *elf_text_symbol;
    573   asection *elf_data_section;
    574   asection *elf_text_section;
    575 };
    576 
    577 /* Get MIPS ELF private object data from BFD's tdata.  */
    578 
    579 #define mips_elf_tdata(bfd) \
    580   ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
    581 
    582 #define TLS_RELOC_P(r_type) \
    583   (r_type == R_MIPS_TLS_DTPMOD32		\
    584    || r_type == R_MIPS_TLS_DTPMOD64		\
    585    || r_type == R_MIPS_TLS_DTPREL32		\
    586    || r_type == R_MIPS_TLS_DTPREL64		\
    587    || r_type == R_MIPS_TLS_GD			\
    588    || r_type == R_MIPS_TLS_LDM			\
    589    || r_type == R_MIPS_TLS_DTPREL_HI16		\
    590    || r_type == R_MIPS_TLS_DTPREL_LO16		\
    591    || r_type == R_MIPS_TLS_GOTTPREL		\
    592    || r_type == R_MIPS_TLS_TPREL32		\
    593    || r_type == R_MIPS_TLS_TPREL64		\
    594    || r_type == R_MIPS_TLS_TPREL_HI16		\
    595    || r_type == R_MIPS_TLS_TPREL_LO16		\
    596    || r_type == R_MIPS16_TLS_GD			\
    597    || r_type == R_MIPS16_TLS_LDM		\
    598    || r_type == R_MIPS16_TLS_DTPREL_HI16	\
    599    || r_type == R_MIPS16_TLS_DTPREL_LO16	\
    600    || r_type == R_MIPS16_TLS_GOTTPREL		\
    601    || r_type == R_MIPS16_TLS_TPREL_HI16		\
    602    || r_type == R_MIPS16_TLS_TPREL_LO16		\
    603    || r_type == R_MICROMIPS_TLS_GD		\
    604    || r_type == R_MICROMIPS_TLS_LDM		\
    605    || r_type == R_MICROMIPS_TLS_DTPREL_HI16	\
    606    || r_type == R_MICROMIPS_TLS_DTPREL_LO16	\
    607    || r_type == R_MICROMIPS_TLS_GOTTPREL	\
    608    || r_type == R_MICROMIPS_TLS_TPREL_HI16	\
    609    || r_type == R_MICROMIPS_TLS_TPREL_LO16)
    610 
    611 /* Structure used to pass information to mips_elf_output_extsym.  */
    612 
    613 struct extsym_info
    614 {
    615   bfd *abfd;
    616   struct bfd_link_info *info;
    617   struct ecoff_debug_info *debug;
    618   const struct ecoff_debug_swap *swap;
    619   bfd_boolean failed;
    620 };
    621 
    622 /* The names of the runtime procedure table symbols used on IRIX5.  */
    623 
    624 static const char * const mips_elf_dynsym_rtproc_names[] =
    625 {
    626   "_procedure_table",
    627   "_procedure_string_table",
    628   "_procedure_table_size",
    629   NULL
    630 };
    631 
    632 /* These structures are used to generate the .compact_rel section on
    633    IRIX5.  */
    634 
    635 typedef struct
    636 {
    637   unsigned long id1;		/* Always one?  */
    638   unsigned long num;		/* Number of compact relocation entries.  */
    639   unsigned long id2;		/* Always two?  */
    640   unsigned long offset;		/* The file offset of the first relocation.  */
    641   unsigned long reserved0;	/* Zero?  */
    642   unsigned long reserved1;	/* Zero?  */
    643 } Elf32_compact_rel;
    644 
    645 typedef struct
    646 {
    647   bfd_byte id1[4];
    648   bfd_byte num[4];
    649   bfd_byte id2[4];
    650   bfd_byte offset[4];
    651   bfd_byte reserved0[4];
    652   bfd_byte reserved1[4];
    653 } Elf32_External_compact_rel;
    654 
    655 typedef struct
    656 {
    657   unsigned int ctype : 1;	/* 1: long 0: short format. See below.  */
    658   unsigned int rtype : 4;	/* Relocation types. See below.  */
    659   unsigned int dist2to : 8;
    660   unsigned int relvaddr : 19;	/* (VADDR - vaddr of the previous entry)/ 4 */
    661   unsigned long konst;		/* KONST field. See below.  */
    662   unsigned long vaddr;		/* VADDR to be relocated.  */
    663 } Elf32_crinfo;
    664 
    665 typedef struct
    666 {
    667   unsigned int ctype : 1;	/* 1: long 0: short format. See below.  */
    668   unsigned int rtype : 4;	/* Relocation types. See below.  */
    669   unsigned int dist2to : 8;
    670   unsigned int relvaddr : 19;	/* (VADDR - vaddr of the previous entry)/ 4 */
    671   unsigned long konst;		/* KONST field. See below.  */
    672 } Elf32_crinfo2;
    673 
    674 typedef struct
    675 {
    676   bfd_byte info[4];
    677   bfd_byte konst[4];
    678   bfd_byte vaddr[4];
    679 } Elf32_External_crinfo;
    680 
    681 typedef struct
    682 {
    683   bfd_byte info[4];
    684   bfd_byte konst[4];
    685 } Elf32_External_crinfo2;
    686 
    687 /* These are the constants used to swap the bitfields in a crinfo.  */
    688 
    689 #define CRINFO_CTYPE (0x1)
    690 #define CRINFO_CTYPE_SH (31)
    691 #define CRINFO_RTYPE (0xf)
    692 #define CRINFO_RTYPE_SH (27)
    693 #define CRINFO_DIST2TO (0xff)
    694 #define CRINFO_DIST2TO_SH (19)
    695 #define CRINFO_RELVADDR (0x7ffff)
    696 #define CRINFO_RELVADDR_SH (0)
    697 
    698 /* A compact relocation info has long (3 words) or short (2 words)
    699    formats.  A short format doesn't have VADDR field and relvaddr
    700    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
    701 #define CRF_MIPS_LONG			1
    702 #define CRF_MIPS_SHORT			0
    703 
    704 /* There are 4 types of compact relocation at least. The value KONST
    705    has different meaning for each type:
    706 
    707    (type)		(konst)
    708    CT_MIPS_REL32	Address in data
    709    CT_MIPS_WORD		Address in word (XXX)
    710    CT_MIPS_GPHI_LO	GP - vaddr
    711    CT_MIPS_JMPAD	Address to jump
    712    */
    713 
    714 #define CRT_MIPS_REL32			0xa
    715 #define CRT_MIPS_WORD			0xb
    716 #define CRT_MIPS_GPHI_LO		0xc
    717 #define CRT_MIPS_JMPAD			0xd
    718 
    719 #define mips_elf_set_cr_format(x,format)	((x).ctype = (format))
    720 #define mips_elf_set_cr_type(x,type)		((x).rtype = (type))
    721 #define mips_elf_set_cr_dist2to(x,v)		((x).dist2to = (v))
    722 #define mips_elf_set_cr_relvaddr(x,d)		((x).relvaddr = (d)<<2)
    723 
    724 /* The structure of the runtime procedure descriptor created by the
    726    loader for use by the static exception system.  */
    727 
    728 typedef struct runtime_pdr {
    729 	bfd_vma	adr;		/* Memory address of start of procedure.  */
    730 	long	regmask;	/* Save register mask.  */
    731 	long	regoffset;	/* Save register offset.  */
    732 	long	fregmask;	/* Save floating point register mask.  */
    733 	long	fregoffset;	/* Save floating point register offset.  */
    734 	long	frameoffset;	/* Frame size.  */
    735 	short	framereg;	/* Frame pointer register.  */
    736 	short	pcreg;		/* Offset or reg of return pc.  */
    737 	long	irpss;		/* Index into the runtime string table.  */
    738 	long	reserved;
    739 	struct exception_info *exception_info;/* Pointer to exception array.  */
    740 } RPDR, *pRPDR;
    741 #define cbRPDR sizeof (RPDR)
    742 #define rpdNil ((pRPDR) 0)
    743 
    744 static struct mips_got_entry *mips_elf_create_local_got_entry
    746   (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
    747    struct mips_elf_link_hash_entry *, int);
    748 static bfd_boolean mips_elf_sort_hash_table_f
    749   (struct mips_elf_link_hash_entry *, void *);
    750 static bfd_vma mips_elf_high
    751   (bfd_vma);
    752 static bfd_boolean mips_elf_create_dynamic_relocation
    753   (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
    754    struct mips_elf_link_hash_entry *, asection *, bfd_vma,
    755    bfd_vma *, asection *);
    756 static bfd_vma mips_elf_adjust_gp
    757   (bfd *, struct mips_got_info *, bfd *);
    758 
    759 /* This will be used when we sort the dynamic relocation records.  */
    760 static bfd *reldyn_sorting_bfd;
    761 
    762 /* True if ABFD is for CPUs with load interlocking that include
    763    non-MIPS1 CPUs and R3900.  */
    764 #define LOAD_INTERLOCKS_P(abfd) \
    765   (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
    766    || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
    767 
    768 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
    769    This should be safe for all architectures.  We enable this predicate
    770    for RM9000 for now.  */
    771 #define JAL_TO_BAL_P(abfd) \
    772   ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
    773 
    774 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
    775    This should be safe for all architectures.  We enable this predicate for
    776    all CPUs.  */
    777 #define JALR_TO_BAL_P(abfd) 1
    778 
    779 /* True if ABFD is for CPUs that are faster if JR is converted to B.
    780    This should be safe for all architectures.  We enable this predicate for
    781    all CPUs.  */
    782 #define JR_TO_B_P(abfd) 1
    783 
    784 /* True if ABFD is a PIC object.  */
    785 #define PIC_OBJECT_P(abfd) \
    786   ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
    787 
    788 /* Nonzero if ABFD is using the O32 ABI.  */
    789 #define ABI_O32_P(abfd) \
    790   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
    791 
    792 /* Nonzero if ABFD is using the N32 ABI.  */
    793 #define ABI_N32_P(abfd) \
    794   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
    795 
    796 /* Nonzero if ABFD is using the N64 ABI.  */
    797 #define ABI_64_P(abfd) \
    798   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
    799 
    800 /* Nonzero if ABFD is using NewABI conventions.  */
    801 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
    802 
    803 /* Nonzero if ABFD has microMIPS code.  */
    804 #define MICROMIPS_P(abfd) \
    805   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
    806 
    807 /* Nonzero if ABFD is MIPS R6.  */
    808 #define MIPSR6_P(abfd) \
    809   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
    810     || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
    811 
    812 /* The IRIX compatibility level we are striving for.  */
    813 #define IRIX_COMPAT(abfd) \
    814   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
    815 
    816 /* Whether we are trying to be compatible with IRIX at all.  */
    817 #define SGI_COMPAT(abfd) \
    818   (IRIX_COMPAT (abfd) != ict_none)
    819 
    820 /* The name of the options section.  */
    821 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
    822   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
    823 
    824 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
    825    Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
    826 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
    827   (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
    828 
    829 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section.  */
    830 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
    831   (strcmp (NAME, ".MIPS.abiflags") == 0)
    832 
    833 /* Whether the section is readonly.  */
    834 #define MIPS_ELF_READONLY_SECTION(sec) \
    835   ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))		\
    836    == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
    837 
    838 /* The name of the stub section.  */
    839 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
    840 
    841 /* The size of an external REL relocation.  */
    842 #define MIPS_ELF_REL_SIZE(abfd) \
    843   (get_elf_backend_data (abfd)->s->sizeof_rel)
    844 
    845 /* The size of an external RELA relocation.  */
    846 #define MIPS_ELF_RELA_SIZE(abfd) \
    847   (get_elf_backend_data (abfd)->s->sizeof_rela)
    848 
    849 /* The size of an external dynamic table entry.  */
    850 #define MIPS_ELF_DYN_SIZE(abfd) \
    851   (get_elf_backend_data (abfd)->s->sizeof_dyn)
    852 
    853 /* The size of a GOT entry.  */
    854 #define MIPS_ELF_GOT_SIZE(abfd) \
    855   (get_elf_backend_data (abfd)->s->arch_size / 8)
    856 
    857 /* The size of the .rld_map section. */
    858 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
    859   (get_elf_backend_data (abfd)->s->arch_size / 8)
    860 
    861 /* The size of a symbol-table entry.  */
    862 #define MIPS_ELF_SYM_SIZE(abfd) \
    863   (get_elf_backend_data (abfd)->s->sizeof_sym)
    864 
    865 /* The default alignment for sections, as a power of two.  */
    866 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)				\
    867   (get_elf_backend_data (abfd)->s->log_file_align)
    868 
    869 /* Get word-sized data.  */
    870 #define MIPS_ELF_GET_WORD(abfd, ptr) \
    871   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
    872 
    873 /* Put out word-sized data.  */
    874 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)	\
    875   (ABI_64_P (abfd) 				\
    876    ? bfd_put_64 (abfd, val, ptr) 		\
    877    : bfd_put_32 (abfd, val, ptr))
    878 
    879 /* The opcode for word-sized loads (LW or LD).  */
    880 #define MIPS_ELF_LOAD_WORD(abfd) \
    881   (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
    882 
    883 /* Add a dynamic symbol table-entry.  */
    884 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)	\
    885   _bfd_elf_add_dynamic_entry (info, tag, val)
    886 
    887 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)			\
    888   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
    889 
    890 /* The name of the dynamic relocation section.  */
    891 #define MIPS_ELF_REL_DYN_NAME(INFO) \
    892   (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
    893 
    894 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
    895    from smaller values.  Start with zero, widen, *then* decrement.  */
    896 #define MINUS_ONE	(((bfd_vma)0) - 1)
    897 #define MINUS_TWO	(((bfd_vma)0) - 2)
    898 
    899 /* The value to write into got[1] for SVR4 targets, to identify it is
    900    a GNU object.  The dynamic linker can then use got[1] to store the
    901    module pointer.  */
    902 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
    903   ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
    904 
    905 /* The offset of $gp from the beginning of the .got section.  */
    906 #define ELF_MIPS_GP_OFFSET(INFO) \
    907   (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
    908 
    909 /* The maximum size of the GOT for it to be addressable using 16-bit
    910    offsets from $gp.  */
    911 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
    912 
    913 /* Instructions which appear in a stub.  */
    914 #define STUB_LW(abfd)							\
    915   ((ABI_64_P (abfd)							\
    916     ? 0xdf998010				/* ld t9,0x8010(gp) */	\
    917     : 0x8f998010))              		/* lw t9,0x8010(gp) */
    918 #define STUB_MOVE(abfd)							\
    919    ((ABI_64_P (abfd)							\
    920      ? 0x03e0782d				/* daddu t7,ra */	\
    921      : 0x03e07821))				/* addu t7,ra */
    922 #define STUB_LUI(VAL) (0x3c180000 + (VAL))	/* lui t8,VAL */
    923 #define STUB_JALR 0x0320f809			/* jalr t9,ra */
    924 #define STUB_ORI(VAL) (0x37180000 + (VAL))	/* ori t8,t8,VAL */
    925 #define STUB_LI16U(VAL) (0x34180000 + (VAL))	/* ori t8,zero,VAL unsigned */
    926 #define STUB_LI16S(abfd, VAL)						\
    927    ((ABI_64_P (abfd)							\
    928     ? (0x64180000 + (VAL))	/* daddiu t8,zero,VAL sign extended */	\
    929     : (0x24180000 + (VAL))))	/* addiu t8,zero,VAL sign extended */
    930 
    931 /* Likewise for the microMIPS ASE.  */
    932 #define STUB_LW_MICROMIPS(abfd)						\
    933   (ABI_64_P (abfd)							\
    934    ? 0xdf3c8010					/* ld t9,0x8010(gp) */	\
    935    : 0xff3c8010)				/* lw t9,0x8010(gp) */
    936 #define STUB_MOVE_MICROMIPS 0x0dff		/* move t7,ra */
    937 #define STUB_MOVE32_MICROMIPS(abfd)					\
    938    (ABI_64_P (abfd)							\
    939     ? 0x581f7950				/* daddu t7,ra,zero */	\
    940     : 0x001f7950)				/* addu t7,ra,zero */
    941 #define STUB_LUI_MICROMIPS(VAL)						\
    942    (0x41b80000 + (VAL))				/* lui t8,VAL */
    943 #define STUB_JALR_MICROMIPS 0x45d9		/* jalr t9 */
    944 #define STUB_JALR32_MICROMIPS 0x03f90f3c	/* jalr ra,t9 */
    945 #define STUB_ORI_MICROMIPS(VAL)						\
    946   (0x53180000 + (VAL))				/* ori t8,t8,VAL */
    947 #define STUB_LI16U_MICROMIPS(VAL)					\
    948   (0x53000000 + (VAL))				/* ori t8,zero,VAL unsigned */
    949 #define STUB_LI16S_MICROMIPS(abfd, VAL)					\
    950    (ABI_64_P (abfd)							\
    951     ? 0x5f000000 + (VAL)	/* daddiu t8,zero,VAL sign extended */	\
    952     : 0x33000000 + (VAL))	/* addiu t8,zero,VAL sign extended */
    953 
    954 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
    955 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
    956 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
    957 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
    958 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
    959 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
    960 
    961 /* The name of the dynamic interpreter.  This is put in the .interp
    962    section.  */
    963 
    964 #define ELF_DYNAMIC_INTERPRETER(abfd) 		\
    965    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" 	\
    966     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" 	\
    967     : "/usr/lib/libc.so.1")
    968 
    969 #ifdef BFD64
    970 #define MNAME(bfd,pre,pos) \
    971   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
    972 #define ELF_R_SYM(bfd, i)					\
    973   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
    974 #define ELF_R_TYPE(bfd, i)					\
    975   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
    976 #define ELF_R_INFO(bfd, s, t)					\
    977   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
    978 #else
    979 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
    980 #define ELF_R_SYM(bfd, i)					\
    981   (ELF32_R_SYM (i))
    982 #define ELF_R_TYPE(bfd, i)					\
    983   (ELF32_R_TYPE (i))
    984 #define ELF_R_INFO(bfd, s, t)					\
    985   (ELF32_R_INFO (s, t))
    986 #endif
    987 
    988   /* The mips16 compiler uses a couple of special sections to handle
    990      floating point arguments.
    991 
    992      Section names that look like .mips16.fn.FNNAME contain stubs that
    993      copy floating point arguments from the fp regs to the gp regs and
    994      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
    995      call should be redirected to the stub instead.  If no 32 bit
    996      function calls FNNAME, the stub should be discarded.  We need to
    997      consider any reference to the function, not just a call, because
    998      if the address of the function is taken we will need the stub,
    999      since the address might be passed to a 32 bit function.
   1000 
   1001      Section names that look like .mips16.call.FNNAME contain stubs
   1002      that copy floating point arguments from the gp regs to the fp
   1003      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
   1004      then any 16 bit function that calls FNNAME should be redirected
   1005      to the stub instead.  If FNNAME is not a 32 bit function, the
   1006      stub should be discarded.
   1007 
   1008      .mips16.call.fp.FNNAME sections are similar, but contain stubs
   1009      which call FNNAME and then copy the return value from the fp regs
   1010      to the gp regs.  These stubs store the return value in $18 while
   1011      calling FNNAME; any function which might call one of these stubs
   1012      must arrange to save $18 around the call.  (This case is not
   1013      needed for 32 bit functions that call 16 bit functions, because
   1014      16 bit functions always return floating point values in both
   1015      $f0/$f1 and $2/$3.)
   1016 
   1017      Note that in all cases FNNAME might be defined statically.
   1018      Therefore, FNNAME is not used literally.  Instead, the relocation
   1019      information will indicate which symbol the section is for.
   1020 
   1021      We record any stubs that we find in the symbol table.  */
   1022 
   1023 #define FN_STUB ".mips16.fn."
   1024 #define CALL_STUB ".mips16.call."
   1025 #define CALL_FP_STUB ".mips16.call.fp."
   1026 
   1027 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
   1028 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
   1029 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
   1030 
   1031 /* The format of the first PLT entry in an O32 executable.  */
   1033 static const bfd_vma mips_o32_exec_plt0_entry[] =
   1034 {
   1035   0x3c1c0000,	/* lui $28, %hi(&GOTPLT[0])				*/
   1036   0x8f990000,	/* lw $25, %lo(&GOTPLT[0])($28)				*/
   1037   0x279c0000,	/* addiu $28, $28, %lo(&GOTPLT[0])			*/
   1038   0x031cc023,	/* subu $24, $24, $28					*/
   1039   0x03e07821,	/* move $15, $31	# 32-bit move (addu)		*/
   1040   0x0018c082,	/* srl $24, $24, 2					*/
   1041   0x0320f809,	/* jalr $25						*/
   1042   0x2718fffe	/* subu $24, $24, 2					*/
   1043 };
   1044 
   1045 /* The format of the first PLT entry in an N32 executable.  Different
   1046    because gp ($28) is not available; we use t2 ($14) instead.  */
   1047 static const bfd_vma mips_n32_exec_plt0_entry[] =
   1048 {
   1049   0x3c0e0000,	/* lui $14, %hi(&GOTPLT[0])				*/
   1050   0x8dd90000,	/* lw $25, %lo(&GOTPLT[0])($14)				*/
   1051   0x25ce0000,	/* addiu $14, $14, %lo(&GOTPLT[0])			*/
   1052   0x030ec023,	/* subu $24, $24, $14					*/
   1053   0x03e07821,	/* move $15, $31	# 32-bit move (addu)		*/
   1054   0x0018c082,	/* srl $24, $24, 2					*/
   1055   0x0320f809,	/* jalr $25						*/
   1056   0x2718fffe	/* subu $24, $24, 2					*/
   1057 };
   1058 
   1059 /* The format of the first PLT entry in an N64 executable.  Different
   1060    from N32 because of the increased size of GOT entries.  */
   1061 static const bfd_vma mips_n64_exec_plt0_entry[] =
   1062 {
   1063   0x3c0e0000,	/* lui $14, %hi(&GOTPLT[0])				*/
   1064   0xddd90000,	/* ld $25, %lo(&GOTPLT[0])($14)				*/
   1065   0x25ce0000,	/* addiu $14, $14, %lo(&GOTPLT[0])			*/
   1066   0x030ec023,	/* subu $24, $24, $14					*/
   1067   0x03e0782d,	/* move $15, $31	# 64-bit move (daddu)		*/
   1068   0x0018c0c2,	/* srl $24, $24, 3					*/
   1069   0x0320f809,	/* jalr $25						*/
   1070   0x2718fffe	/* subu $24, $24, 2					*/
   1071 };
   1072 
   1073 /* The format of the microMIPS first PLT entry in an O32 executable.
   1074    We rely on v0 ($2) rather than t8 ($24) to contain the address
   1075    of the GOTPLT entry handled, so this stub may only be used when
   1076    all the subsequent PLT entries are microMIPS code too.
   1077 
   1078    The trailing NOP is for alignment and correct disassembly only.  */
   1079 static const bfd_vma micromips_o32_exec_plt0_entry[] =
   1080 {
   1081   0x7980, 0x0000,	/* addiupc $3, (&GOTPLT[0]) - .			*/
   1082   0xff23, 0x0000,	/* lw $25, 0($3)				*/
   1083   0x0535,		/* subu $2, $2, $3				*/
   1084   0x2525,		/* srl $2, $2, 2				*/
   1085   0x3302, 0xfffe,	/* subu $24, $2, 2				*/
   1086   0x0dff,		/* move $15, $31				*/
   1087   0x45f9,		/* jalrs $25					*/
   1088   0x0f83,		/* move $28, $3					*/
   1089   0x0c00		/* nop						*/
   1090 };
   1091 
   1092 /* The format of the microMIPS first PLT entry in an O32 executable
   1093    in the insn32 mode.  */
   1094 static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] =
   1095 {
   1096   0x41bc, 0x0000,	/* lui $28, %hi(&GOTPLT[0])			*/
   1097   0xff3c, 0x0000,	/* lw $25, %lo(&GOTPLT[0])($28)			*/
   1098   0x339c, 0x0000,	/* addiu $28, $28, %lo(&GOTPLT[0])		*/
   1099   0x0398, 0xc1d0,	/* subu $24, $24, $28				*/
   1100   0x001f, 0x7950,	/* move $15, $31				*/
   1101   0x0318, 0x1040,	/* srl $24, $24, 2				*/
   1102   0x03f9, 0x0f3c,	/* jalr $25					*/
   1103   0x3318, 0xfffe	/* subu $24, $24, 2				*/
   1104 };
   1105 
   1106 /* The format of subsequent standard PLT entries.  */
   1107 static const bfd_vma mips_exec_plt_entry[] =
   1108 {
   1109   0x3c0f0000,	/* lui $15, %hi(.got.plt entry)			*/
   1110   0x01f90000,	/* l[wd] $25, %lo(.got.plt entry)($15)		*/
   1111   0x25f80000,	/* addiu $24, $15, %lo(.got.plt entry)		*/
   1112   0x03200008	/* jr $25					*/
   1113 };
   1114 
   1115 static const bfd_vma mipsr6_exec_plt_entry[] =
   1116 {
   1117   0x3c0f0000,	/* lui $15, %hi(.got.plt entry)			*/
   1118   0x01f90000,	/* l[wd] $25, %lo(.got.plt entry)($15)		*/
   1119   0x03200009,	/* jr $25					*/
   1120   0x25f80000	/* addiu $24, $15, %lo(.got.plt entry)		*/
   1121 };
   1122 
   1123 static const bfd_vma mipsr6_exec_plt_entry_compact[] =
   1124 {
   1125   0x3c0f0000,	/* lui $15, %hi(.got.plt entry)			*/
   1126   0x01f90000,	/* l[wd] $25, %lo(.got.plt entry)($15)		*/
   1127   0x25f80000,	/* addiu $24, $15, %lo(.got.plt entry)		*/
   1128   0xd8190000	/* jic $25, 0					*/
   1129 };
   1130 
   1131 /* The format of subsequent MIPS16 o32 PLT entries.  We use v0 ($2)
   1132    and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
   1133    directly addressable.  */
   1134 static const bfd_vma mips16_o32_exec_plt_entry[] =
   1135 {
   1136   0xb203,		/* lw $2, 12($pc)			*/
   1137   0x9a60,		/* lw $3, 0($2)				*/
   1138   0x651a,		/* move $24, $2				*/
   1139   0xeb00,		/* jr $3				*/
   1140   0x653b,		/* move $25, $3				*/
   1141   0x6500,		/* nop					*/
   1142   0x0000, 0x0000	/* .word (.got.plt entry)		*/
   1143 };
   1144 
   1145 /* The format of subsequent microMIPS o32 PLT entries.  We use v0 ($2)
   1146    as a temporary because t8 ($24) is not addressable with ADDIUPC.  */
   1147 static const bfd_vma micromips_o32_exec_plt_entry[] =
   1148 {
   1149   0x7900, 0x0000,	/* addiupc $2, (.got.plt entry) - .	*/
   1150   0xff22, 0x0000,	/* lw $25, 0($2)			*/
   1151   0x4599,		/* jr $25				*/
   1152   0x0f02		/* move $24, $2				*/
   1153 };
   1154 
   1155 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode.  */
   1156 static const bfd_vma micromips_insn32_o32_exec_plt_entry[] =
   1157 {
   1158   0x41af, 0x0000,	/* lui $15, %hi(.got.plt entry)		*/
   1159   0xff2f, 0x0000,	/* lw $25, %lo(.got.plt entry)($15)	*/
   1160   0x0019, 0x0f3c,	/* jr $25				*/
   1161   0x330f, 0x0000	/* addiu $24, $15, %lo(.got.plt entry)	*/
   1162 };
   1163 
   1164 /* The format of the first PLT entry in a VxWorks executable.  */
   1165 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
   1166 {
   1167   0x3c190000,	/* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)		*/
   1168   0x27390000,	/* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)	*/
   1169   0x8f390008,	/* lw t9, 8(t9)					*/
   1170   0x00000000,	/* nop						*/
   1171   0x03200008,	/* jr t9					*/
   1172   0x00000000	/* nop						*/
   1173 };
   1174 
   1175 /* The format of subsequent PLT entries.  */
   1176 static const bfd_vma mips_vxworks_exec_plt_entry[] =
   1177 {
   1178   0x10000000,	/* b .PLT_resolver			*/
   1179   0x24180000,	/* li t8, <pltindex>			*/
   1180   0x3c190000,	/* lui t9, %hi(<.got.plt slot>)		*/
   1181   0x27390000,	/* addiu t9, t9, %lo(<.got.plt slot>)	*/
   1182   0x8f390000,	/* lw t9, 0(t9)				*/
   1183   0x00000000,	/* nop					*/
   1184   0x03200008,	/* jr t9				*/
   1185   0x00000000	/* nop					*/
   1186 };
   1187 
   1188 /* The format of the first PLT entry in a VxWorks shared object.  */
   1189 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
   1190 {
   1191   0x8f990008,	/* lw t9, 8(gp)		*/
   1192   0x00000000,	/* nop			*/
   1193   0x03200008,	/* jr t9		*/
   1194   0x00000000,	/* nop			*/
   1195   0x00000000,	/* nop			*/
   1196   0x00000000	/* nop			*/
   1197 };
   1198 
   1199 /* The format of subsequent PLT entries.  */
   1200 static const bfd_vma mips_vxworks_shared_plt_entry[] =
   1201 {
   1202   0x10000000,	/* b .PLT_resolver	*/
   1203   0x24180000	/* li t8, <pltindex>	*/
   1204 };
   1205 
   1206 /* microMIPS 32-bit opcode helper installer.  */
   1208 
   1209 static void
   1210 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
   1211 {
   1212   bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
   1213   bfd_put_16 (abfd,  opcode        & 0xffff, ptr + 2);
   1214 }
   1215 
   1216 /* microMIPS 32-bit opcode helper retriever.  */
   1217 
   1218 static bfd_vma
   1219 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
   1220 {
   1221   return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
   1222 }
   1223 
   1224 /* Look up an entry in a MIPS ELF linker hash table.  */
   1226 
   1227 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)	\
   1228   ((struct mips_elf_link_hash_entry *)					\
   1229    elf_link_hash_lookup (&(table)->root, (string), (create),		\
   1230 			 (copy), (follow)))
   1231 
   1232 /* Traverse a MIPS ELF linker hash table.  */
   1233 
   1234 #define mips_elf_link_hash_traverse(table, func, info)			\
   1235   (elf_link_hash_traverse						\
   1236    (&(table)->root,							\
   1237     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),	\
   1238     (info)))
   1239 
   1240 /* Find the base offsets for thread-local storage in this object,
   1241    for GD/LD and IE/LE respectively.  */
   1242 
   1243 #define TP_OFFSET 0x7000
   1244 #define DTP_OFFSET 0x8000
   1245 
   1246 static bfd_vma
   1247 dtprel_base (struct bfd_link_info *info)
   1248 {
   1249   /* If tls_sec is NULL, we should have signalled an error already.  */
   1250   if (elf_hash_table (info)->tls_sec == NULL)
   1251     return 0;
   1252   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
   1253 }
   1254 
   1255 static bfd_vma
   1256 tprel_base (struct bfd_link_info *info)
   1257 {
   1258   /* If tls_sec is NULL, we should have signalled an error already.  */
   1259   if (elf_hash_table (info)->tls_sec == NULL)
   1260     return 0;
   1261   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
   1262 }
   1263 
   1264 /* Create an entry in a MIPS ELF linker hash table.  */
   1265 
   1266 static struct bfd_hash_entry *
   1267 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
   1268 			    struct bfd_hash_table *table, const char *string)
   1269 {
   1270   struct mips_elf_link_hash_entry *ret =
   1271     (struct mips_elf_link_hash_entry *) entry;
   1272 
   1273   /* Allocate the structure if it has not already been allocated by a
   1274      subclass.  */
   1275   if (ret == NULL)
   1276     ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
   1277   if (ret == NULL)
   1278     return (struct bfd_hash_entry *) ret;
   1279 
   1280   /* Call the allocation method of the superclass.  */
   1281   ret = ((struct mips_elf_link_hash_entry *)
   1282 	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
   1283 				     table, string));
   1284   if (ret != NULL)
   1285     {
   1286       /* Set local fields.  */
   1287       memset (&ret->esym, 0, sizeof (EXTR));
   1288       /* We use -2 as a marker to indicate that the information has
   1289 	 not been set.  -1 means there is no associated ifd.  */
   1290       ret->esym.ifd = -2;
   1291       ret->la25_stub = 0;
   1292       ret->possibly_dynamic_relocs = 0;
   1293       ret->fn_stub = NULL;
   1294       ret->call_stub = NULL;
   1295       ret->call_fp_stub = NULL;
   1296       ret->global_got_area = GGA_NONE;
   1297       ret->got_only_for_calls = TRUE;
   1298       ret->readonly_reloc = FALSE;
   1299       ret->has_static_relocs = FALSE;
   1300       ret->no_fn_stub = FALSE;
   1301       ret->need_fn_stub = FALSE;
   1302       ret->has_nonpic_branches = FALSE;
   1303       ret->needs_lazy_stub = FALSE;
   1304       ret->use_plt_entry = FALSE;
   1305     }
   1306 
   1307   return (struct bfd_hash_entry *) ret;
   1308 }
   1309 
   1310 /* Allocate MIPS ELF private object data.  */
   1311 
   1312 bfd_boolean
   1313 _bfd_mips_elf_mkobject (bfd *abfd)
   1314 {
   1315   return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
   1316 				  MIPS_ELF_DATA);
   1317 }
   1318 
   1319 bfd_boolean
   1320 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
   1321 {
   1322   if (!sec->used_by_bfd)
   1323     {
   1324       struct _mips_elf_section_data *sdata;
   1325       bfd_size_type amt = sizeof (*sdata);
   1326 
   1327       sdata = bfd_zalloc (abfd, amt);
   1328       if (sdata == NULL)
   1329 	return FALSE;
   1330       sec->used_by_bfd = sdata;
   1331     }
   1332 
   1333   return _bfd_elf_new_section_hook (abfd, sec);
   1334 }
   1335 
   1336 /* Read ECOFF debugging information from a .mdebug section into a
   1338    ecoff_debug_info structure.  */
   1339 
   1340 bfd_boolean
   1341 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
   1342 			       struct ecoff_debug_info *debug)
   1343 {
   1344   HDRR *symhdr;
   1345   const struct ecoff_debug_swap *swap;
   1346   char *ext_hdr;
   1347 
   1348   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
   1349   memset (debug, 0, sizeof (*debug));
   1350 
   1351   ext_hdr = bfd_malloc (swap->external_hdr_size);
   1352   if (ext_hdr == NULL && swap->external_hdr_size != 0)
   1353     goto error_return;
   1354 
   1355   if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
   1356 				  swap->external_hdr_size))
   1357     goto error_return;
   1358 
   1359   symhdr = &debug->symbolic_header;
   1360   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
   1361 
   1362   /* The symbolic header contains absolute file offsets and sizes to
   1363      read.  */
   1364 #define READ(ptr, offset, count, size, type)				\
   1365   if (symhdr->count == 0)						\
   1366     debug->ptr = NULL;							\
   1367   else									\
   1368     {									\
   1369       bfd_size_type amt = (bfd_size_type) size * symhdr->count;		\
   1370       debug->ptr = bfd_malloc (amt);					\
   1371       if (debug->ptr == NULL)						\
   1372 	goto error_return;						\
   1373       if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0		\
   1374 	  || bfd_bread (debug->ptr, amt, abfd) != amt)			\
   1375 	goto error_return;						\
   1376     }
   1377 
   1378   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
   1379   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
   1380   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
   1381   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
   1382   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
   1383   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
   1384 	union aux_ext *);
   1385   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
   1386   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
   1387   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
   1388   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
   1389   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
   1390 #undef READ
   1391 
   1392   debug->fdr = NULL;
   1393 
   1394   return TRUE;
   1395 
   1396  error_return:
   1397   if (ext_hdr != NULL)
   1398     free (ext_hdr);
   1399   if (debug->line != NULL)
   1400     free (debug->line);
   1401   if (debug->external_dnr != NULL)
   1402     free (debug->external_dnr);
   1403   if (debug->external_pdr != NULL)
   1404     free (debug->external_pdr);
   1405   if (debug->external_sym != NULL)
   1406     free (debug->external_sym);
   1407   if (debug->external_opt != NULL)
   1408     free (debug->external_opt);
   1409   if (debug->external_aux != NULL)
   1410     free (debug->external_aux);
   1411   if (debug->ss != NULL)
   1412     free (debug->ss);
   1413   if (debug->ssext != NULL)
   1414     free (debug->ssext);
   1415   if (debug->external_fdr != NULL)
   1416     free (debug->external_fdr);
   1417   if (debug->external_rfd != NULL)
   1418     free (debug->external_rfd);
   1419   if (debug->external_ext != NULL)
   1420     free (debug->external_ext);
   1421   return FALSE;
   1422 }
   1423 
   1424 /* Swap RPDR (runtime procedure table entry) for output.  */
   1426 
   1427 static void
   1428 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
   1429 {
   1430   H_PUT_S32 (abfd, in->adr, ex->p_adr);
   1431   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
   1432   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
   1433   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
   1434   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
   1435   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
   1436 
   1437   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
   1438   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
   1439 
   1440   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
   1441 }
   1442 
   1443 /* Create a runtime procedure table from the .mdebug section.  */
   1444 
   1445 static bfd_boolean
   1446 mips_elf_create_procedure_table (void *handle, bfd *abfd,
   1447 				 struct bfd_link_info *info, asection *s,
   1448 				 struct ecoff_debug_info *debug)
   1449 {
   1450   const struct ecoff_debug_swap *swap;
   1451   HDRR *hdr = &debug->symbolic_header;
   1452   RPDR *rpdr, *rp;
   1453   struct rpdr_ext *erp;
   1454   void *rtproc;
   1455   struct pdr_ext *epdr;
   1456   struct sym_ext *esym;
   1457   char *ss, **sv;
   1458   char *str;
   1459   bfd_size_type size;
   1460   bfd_size_type count;
   1461   unsigned long sindex;
   1462   unsigned long i;
   1463   PDR pdr;
   1464   SYMR sym;
   1465   const char *no_name_func = _("static procedure (no name)");
   1466 
   1467   epdr = NULL;
   1468   rpdr = NULL;
   1469   esym = NULL;
   1470   ss = NULL;
   1471   sv = NULL;
   1472 
   1473   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
   1474 
   1475   sindex = strlen (no_name_func) + 1;
   1476   count = hdr->ipdMax;
   1477   if (count > 0)
   1478     {
   1479       size = swap->external_pdr_size;
   1480 
   1481       epdr = bfd_malloc (size * count);
   1482       if (epdr == NULL)
   1483 	goto error_return;
   1484 
   1485       if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
   1486 	goto error_return;
   1487 
   1488       size = sizeof (RPDR);
   1489       rp = rpdr = bfd_malloc (size * count);
   1490       if (rpdr == NULL)
   1491 	goto error_return;
   1492 
   1493       size = sizeof (char *);
   1494       sv = bfd_malloc (size * count);
   1495       if (sv == NULL)
   1496 	goto error_return;
   1497 
   1498       count = hdr->isymMax;
   1499       size = swap->external_sym_size;
   1500       esym = bfd_malloc (size * count);
   1501       if (esym == NULL)
   1502 	goto error_return;
   1503 
   1504       if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
   1505 	goto error_return;
   1506 
   1507       count = hdr->issMax;
   1508       ss = bfd_malloc (count);
   1509       if (ss == NULL)
   1510 	goto error_return;
   1511       if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
   1512 	goto error_return;
   1513 
   1514       count = hdr->ipdMax;
   1515       for (i = 0; i < (unsigned long) count; i++, rp++)
   1516 	{
   1517 	  (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
   1518 	  (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
   1519 	  rp->adr = sym.value;
   1520 	  rp->regmask = pdr.regmask;
   1521 	  rp->regoffset = pdr.regoffset;
   1522 	  rp->fregmask = pdr.fregmask;
   1523 	  rp->fregoffset = pdr.fregoffset;
   1524 	  rp->frameoffset = pdr.frameoffset;
   1525 	  rp->framereg = pdr.framereg;
   1526 	  rp->pcreg = pdr.pcreg;
   1527 	  rp->irpss = sindex;
   1528 	  sv[i] = ss + sym.iss;
   1529 	  sindex += strlen (sv[i]) + 1;
   1530 	}
   1531     }
   1532 
   1533   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
   1534   size = BFD_ALIGN (size, 16);
   1535   rtproc = bfd_alloc (abfd, size);
   1536   if (rtproc == NULL)
   1537     {
   1538       mips_elf_hash_table (info)->procedure_count = 0;
   1539       goto error_return;
   1540     }
   1541 
   1542   mips_elf_hash_table (info)->procedure_count = count + 2;
   1543 
   1544   erp = rtproc;
   1545   memset (erp, 0, sizeof (struct rpdr_ext));
   1546   erp++;
   1547   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
   1548   strcpy (str, no_name_func);
   1549   str += strlen (no_name_func) + 1;
   1550   for (i = 0; i < count; i++)
   1551     {
   1552       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
   1553       strcpy (str, sv[i]);
   1554       str += strlen (sv[i]) + 1;
   1555     }
   1556   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
   1557 
   1558   /* Set the size and contents of .rtproc section.  */
   1559   s->size = size;
   1560   s->contents = rtproc;
   1561 
   1562   /* Skip this section later on (I don't think this currently
   1563      matters, but someday it might).  */
   1564   s->map_head.link_order = NULL;
   1565 
   1566   if (epdr != NULL)
   1567     free (epdr);
   1568   if (rpdr != NULL)
   1569     free (rpdr);
   1570   if (esym != NULL)
   1571     free (esym);
   1572   if (ss != NULL)
   1573     free (ss);
   1574   if (sv != NULL)
   1575     free (sv);
   1576 
   1577   return TRUE;
   1578 
   1579  error_return:
   1580   if (epdr != NULL)
   1581     free (epdr);
   1582   if (rpdr != NULL)
   1583     free (rpdr);
   1584   if (esym != NULL)
   1585     free (esym);
   1586   if (ss != NULL)
   1587     free (ss);
   1588   if (sv != NULL)
   1589     free (sv);
   1590   return FALSE;
   1591 }
   1592 
   1593 /* We're going to create a stub for H.  Create a symbol for the stub's
   1595    value and size, to help make the disassembly easier to read.  */
   1596 
   1597 static bfd_boolean
   1598 mips_elf_create_stub_symbol (struct bfd_link_info *info,
   1599 			     struct mips_elf_link_hash_entry *h,
   1600 			     const char *prefix, asection *s, bfd_vma value,
   1601 			     bfd_vma size)
   1602 {
   1603   struct bfd_link_hash_entry *bh;
   1604   struct elf_link_hash_entry *elfh;
   1605   const char *name;
   1606 
   1607   if (ELF_ST_IS_MICROMIPS (h->root.other))
   1608     value |= 1;
   1609 
   1610   /* Create a new symbol.  */
   1611   name = ACONCAT ((prefix, h->root.root.root.string, NULL));
   1612   bh = NULL;
   1613   if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
   1614 					 BSF_LOCAL, s, value, NULL,
   1615 					 TRUE, FALSE, &bh))
   1616     return FALSE;
   1617 
   1618   /* Make it a local function.  */
   1619   elfh = (struct elf_link_hash_entry *) bh;
   1620   elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
   1621   elfh->size = size;
   1622   elfh->forced_local = 1;
   1623   return TRUE;
   1624 }
   1625 
   1626 /* We're about to redefine H.  Create a symbol to represent H's
   1627    current value and size, to help make the disassembly easier
   1628    to read.  */
   1629 
   1630 static bfd_boolean
   1631 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
   1632 			       struct mips_elf_link_hash_entry *h,
   1633 			       const char *prefix)
   1634 {
   1635   struct bfd_link_hash_entry *bh;
   1636   struct elf_link_hash_entry *elfh;
   1637   const char *name;
   1638   asection *s;
   1639   bfd_vma value;
   1640 
   1641   /* Read the symbol's value.  */
   1642   BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
   1643 	      || h->root.root.type == bfd_link_hash_defweak);
   1644   s = h->root.root.u.def.section;
   1645   value = h->root.root.u.def.value;
   1646 
   1647   /* Create a new symbol.  */
   1648   name = ACONCAT ((prefix, h->root.root.root.string, NULL));
   1649   bh = NULL;
   1650   if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
   1651 					 BSF_LOCAL, s, value, NULL,
   1652 					 TRUE, FALSE, &bh))
   1653     return FALSE;
   1654 
   1655   /* Make it local and copy the other attributes from H.  */
   1656   elfh = (struct elf_link_hash_entry *) bh;
   1657   elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
   1658   elfh->other = h->root.other;
   1659   elfh->size = h->root.size;
   1660   elfh->forced_local = 1;
   1661   return TRUE;
   1662 }
   1663 
   1664 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
   1665    function rather than to a hard-float stub.  */
   1666 
   1667 static bfd_boolean
   1668 section_allows_mips16_refs_p (asection *section)
   1669 {
   1670   const char *name;
   1671 
   1672   name = bfd_get_section_name (section->owner, section);
   1673   return (FN_STUB_P (name)
   1674 	  || CALL_STUB_P (name)
   1675 	  || CALL_FP_STUB_P (name)
   1676 	  || strcmp (name, ".pdr") == 0);
   1677 }
   1678 
   1679 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
   1680    stub section of some kind.  Return the R_SYMNDX of the target
   1681    function, or 0 if we can't decide which function that is.  */
   1682 
   1683 static unsigned long
   1684 mips16_stub_symndx (const struct elf_backend_data *bed,
   1685 		    asection *sec ATTRIBUTE_UNUSED,
   1686 		    const Elf_Internal_Rela *relocs,
   1687 		    const Elf_Internal_Rela *relend)
   1688 {
   1689   int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
   1690   const Elf_Internal_Rela *rel;
   1691 
   1692   /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
   1693      one in a compound relocation.  */
   1694   for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
   1695     if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
   1696       return ELF_R_SYM (sec->owner, rel->r_info);
   1697 
   1698   /* Otherwise trust the first relocation, whatever its kind.  This is
   1699      the traditional behavior.  */
   1700   if (relocs < relend)
   1701     return ELF_R_SYM (sec->owner, relocs->r_info);
   1702 
   1703   return 0;
   1704 }
   1705 
   1706 /* Check the mips16 stubs for a particular symbol, and see if we can
   1707    discard them.  */
   1708 
   1709 static void
   1710 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
   1711 			     struct mips_elf_link_hash_entry *h)
   1712 {
   1713   /* Dynamic symbols must use the standard call interface, in case other
   1714      objects try to call them.  */
   1715   if (h->fn_stub != NULL
   1716       && h->root.dynindx != -1)
   1717     {
   1718       mips_elf_create_shadow_symbol (info, h, ".mips16.");
   1719       h->need_fn_stub = TRUE;
   1720     }
   1721 
   1722   if (h->fn_stub != NULL
   1723       && ! h->need_fn_stub)
   1724     {
   1725       /* We don't need the fn_stub; the only references to this symbol
   1726          are 16 bit calls.  Clobber the size to 0 to prevent it from
   1727          being included in the link.  */
   1728       h->fn_stub->size = 0;
   1729       h->fn_stub->flags &= ~SEC_RELOC;
   1730       h->fn_stub->reloc_count = 0;
   1731       h->fn_stub->flags |= SEC_EXCLUDE;
   1732     }
   1733 
   1734   if (h->call_stub != NULL
   1735       && ELF_ST_IS_MIPS16 (h->root.other))
   1736     {
   1737       /* We don't need the call_stub; this is a 16 bit function, so
   1738          calls from other 16 bit functions are OK.  Clobber the size
   1739          to 0 to prevent it from being included in the link.  */
   1740       h->call_stub->size = 0;
   1741       h->call_stub->flags &= ~SEC_RELOC;
   1742       h->call_stub->reloc_count = 0;
   1743       h->call_stub->flags |= SEC_EXCLUDE;
   1744     }
   1745 
   1746   if (h->call_fp_stub != NULL
   1747       && ELF_ST_IS_MIPS16 (h->root.other))
   1748     {
   1749       /* We don't need the call_stub; this is a 16 bit function, so
   1750          calls from other 16 bit functions are OK.  Clobber the size
   1751          to 0 to prevent it from being included in the link.  */
   1752       h->call_fp_stub->size = 0;
   1753       h->call_fp_stub->flags &= ~SEC_RELOC;
   1754       h->call_fp_stub->reloc_count = 0;
   1755       h->call_fp_stub->flags |= SEC_EXCLUDE;
   1756     }
   1757 }
   1758 
   1759 /* Hashtable callbacks for mips_elf_la25_stubs.  */
   1760 
   1761 static hashval_t
   1762 mips_elf_la25_stub_hash (const void *entry_)
   1763 {
   1764   const struct mips_elf_la25_stub *entry;
   1765 
   1766   entry = (struct mips_elf_la25_stub *) entry_;
   1767   return entry->h->root.root.u.def.section->id
   1768     + entry->h->root.root.u.def.value;
   1769 }
   1770 
   1771 static int
   1772 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
   1773 {
   1774   const struct mips_elf_la25_stub *entry1, *entry2;
   1775 
   1776   entry1 = (struct mips_elf_la25_stub *) entry1_;
   1777   entry2 = (struct mips_elf_la25_stub *) entry2_;
   1778   return ((entry1->h->root.root.u.def.section
   1779 	   == entry2->h->root.root.u.def.section)
   1780 	  && (entry1->h->root.root.u.def.value
   1781 	      == entry2->h->root.root.u.def.value));
   1782 }
   1783 
   1784 /* Called by the linker to set up the la25 stub-creation code.  FN is
   1785    the linker's implementation of add_stub_function.  Return true on
   1786    success.  */
   1787 
   1788 bfd_boolean
   1789 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
   1790 			  asection *(*fn) (const char *, asection *,
   1791 					   asection *))
   1792 {
   1793   struct mips_elf_link_hash_table *htab;
   1794 
   1795   htab = mips_elf_hash_table (info);
   1796   if (htab == NULL)
   1797     return FALSE;
   1798 
   1799   htab->add_stub_section = fn;
   1800   htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
   1801 				      mips_elf_la25_stub_eq, NULL);
   1802   if (htab->la25_stubs == NULL)
   1803     return FALSE;
   1804 
   1805   return TRUE;
   1806 }
   1807 
   1808 /* Return true if H is a locally-defined PIC function, in the sense
   1809    that it or its fn_stub might need $25 to be valid on entry.
   1810    Note that MIPS16 functions set up $gp using PC-relative instructions,
   1811    so they themselves never need $25 to be valid.  Only non-MIPS16
   1812    entry points are of interest here.  */
   1813 
   1814 static bfd_boolean
   1815 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
   1816 {
   1817   return ((h->root.root.type == bfd_link_hash_defined
   1818 	   || h->root.root.type == bfd_link_hash_defweak)
   1819 	  && h->root.def_regular
   1820 	  && !bfd_is_abs_section (h->root.root.u.def.section)
   1821 	  && (!ELF_ST_IS_MIPS16 (h->root.other)
   1822 	      || (h->fn_stub && h->need_fn_stub))
   1823 	  && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
   1824 	      || ELF_ST_IS_MIPS_PIC (h->root.other)));
   1825 }
   1826 
   1827 /* Set *SEC to the input section that contains the target of STUB.
   1828    Return the offset of the target from the start of that section.  */
   1829 
   1830 static bfd_vma
   1831 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
   1832 			  asection **sec)
   1833 {
   1834   if (ELF_ST_IS_MIPS16 (stub->h->root.other))
   1835     {
   1836       BFD_ASSERT (stub->h->need_fn_stub);
   1837       *sec = stub->h->fn_stub;
   1838       return 0;
   1839     }
   1840   else
   1841     {
   1842       *sec = stub->h->root.root.u.def.section;
   1843       return stub->h->root.root.u.def.value;
   1844     }
   1845 }
   1846 
   1847 /* STUB describes an la25 stub that we have decided to implement
   1848    by inserting an LUI/ADDIU pair before the target function.
   1849    Create the section and redirect the function symbol to it.  */
   1850 
   1851 static bfd_boolean
   1852 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
   1853 			 struct bfd_link_info *info)
   1854 {
   1855   struct mips_elf_link_hash_table *htab;
   1856   char *name;
   1857   asection *s, *input_section;
   1858   unsigned int align;
   1859 
   1860   htab = mips_elf_hash_table (info);
   1861   if (htab == NULL)
   1862     return FALSE;
   1863 
   1864   /* Create a unique name for the new section.  */
   1865   name = bfd_malloc (11 + sizeof (".text.stub."));
   1866   if (name == NULL)
   1867     return FALSE;
   1868   sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
   1869 
   1870   /* Create the section.  */
   1871   mips_elf_get_la25_target (stub, &input_section);
   1872   s = htab->add_stub_section (name, input_section,
   1873 			      input_section->output_section);
   1874   if (s == NULL)
   1875     return FALSE;
   1876 
   1877   /* Make sure that any padding goes before the stub.  */
   1878   align = input_section->alignment_power;
   1879   if (!bfd_set_section_alignment (s->owner, s, align))
   1880     return FALSE;
   1881   if (align > 3)
   1882     s->size = (1 << align) - 8;
   1883 
   1884   /* Create a symbol for the stub.  */
   1885   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
   1886   stub->stub_section = s;
   1887   stub->offset = s->size;
   1888 
   1889   /* Allocate room for it.  */
   1890   s->size += 8;
   1891   return TRUE;
   1892 }
   1893 
   1894 /* STUB describes an la25 stub that we have decided to implement
   1895    with a separate trampoline.  Allocate room for it and redirect
   1896    the function symbol to it.  */
   1897 
   1898 static bfd_boolean
   1899 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
   1900 			      struct bfd_link_info *info)
   1901 {
   1902   struct mips_elf_link_hash_table *htab;
   1903   asection *s;
   1904 
   1905   htab = mips_elf_hash_table (info);
   1906   if (htab == NULL)
   1907     return FALSE;
   1908 
   1909   /* Create a trampoline section, if we haven't already.  */
   1910   s = htab->strampoline;
   1911   if (s == NULL)
   1912     {
   1913       asection *input_section = stub->h->root.root.u.def.section;
   1914       s = htab->add_stub_section (".text", NULL,
   1915 				  input_section->output_section);
   1916       if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
   1917 	return FALSE;
   1918       htab->strampoline = s;
   1919     }
   1920 
   1921   /* Create a symbol for the stub.  */
   1922   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
   1923   stub->stub_section = s;
   1924   stub->offset = s->size;
   1925 
   1926   /* Allocate room for it.  */
   1927   s->size += 16;
   1928   return TRUE;
   1929 }
   1930 
   1931 /* H describes a symbol that needs an la25 stub.  Make sure that an
   1932    appropriate stub exists and point H at it.  */
   1933 
   1934 static bfd_boolean
   1935 mips_elf_add_la25_stub (struct bfd_link_info *info,
   1936 			struct mips_elf_link_hash_entry *h)
   1937 {
   1938   struct mips_elf_link_hash_table *htab;
   1939   struct mips_elf_la25_stub search, *stub;
   1940   bfd_boolean use_trampoline_p;
   1941   asection *s;
   1942   bfd_vma value;
   1943   void **slot;
   1944 
   1945   /* Describe the stub we want.  */
   1946   search.stub_section = NULL;
   1947   search.offset = 0;
   1948   search.h = h;
   1949 
   1950   /* See if we've already created an equivalent stub.  */
   1951   htab = mips_elf_hash_table (info);
   1952   if (htab == NULL)
   1953     return FALSE;
   1954 
   1955   slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
   1956   if (slot == NULL)
   1957     return FALSE;
   1958 
   1959   stub = (struct mips_elf_la25_stub *) *slot;
   1960   if (stub != NULL)
   1961     {
   1962       /* We can reuse the existing stub.  */
   1963       h->la25_stub = stub;
   1964       return TRUE;
   1965     }
   1966 
   1967   /* Create a permanent copy of ENTRY and add it to the hash table.  */
   1968   stub = bfd_malloc (sizeof (search));
   1969   if (stub == NULL)
   1970     return FALSE;
   1971   *stub = search;
   1972   *slot = stub;
   1973 
   1974   /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
   1975      of the section and if we would need no more than 2 nops.  */
   1976   value = mips_elf_get_la25_target (stub, &s);
   1977   use_trampoline_p = (value != 0 || s->alignment_power > 4);
   1978 
   1979   h->la25_stub = stub;
   1980   return (use_trampoline_p
   1981 	  ? mips_elf_add_la25_trampoline (stub, info)
   1982 	  : mips_elf_add_la25_intro (stub, info));
   1983 }
   1984 
   1985 /* A mips_elf_link_hash_traverse callback that is called before sizing
   1986    sections.  DATA points to a mips_htab_traverse_info structure.  */
   1987 
   1988 static bfd_boolean
   1989 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
   1990 {
   1991   struct mips_htab_traverse_info *hti;
   1992 
   1993   hti = (struct mips_htab_traverse_info *) data;
   1994   if (!hti->info->relocatable)
   1995     mips_elf_check_mips16_stubs (hti->info, h);
   1996 
   1997   if (mips_elf_local_pic_function_p (h))
   1998     {
   1999       /* PR 12845: If H is in a section that has been garbage
   2000 	 collected it will have its output section set to *ABS*.  */
   2001       if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
   2002 	return TRUE;
   2003 
   2004       /* H is a function that might need $25 to be valid on entry.
   2005 	 If we're creating a non-PIC relocatable object, mark H as
   2006 	 being PIC.  If we're creating a non-relocatable object with
   2007 	 non-PIC branches and jumps to H, make sure that H has an la25
   2008 	 stub.  */
   2009       if (hti->info->relocatable)
   2010 	{
   2011 	  if (!PIC_OBJECT_P (hti->output_bfd))
   2012 	    h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
   2013 	}
   2014       else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
   2015 	{
   2016 	  hti->error = TRUE;
   2017 	  return FALSE;
   2018 	}
   2019     }
   2020   return TRUE;
   2021 }
   2022 
   2023 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
   2025    Most mips16 instructions are 16 bits, but these instructions
   2026    are 32 bits.
   2027 
   2028    The format of these instructions is:
   2029 
   2030    +--------------+--------------------------------+
   2031    |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
   2032    +--------------+--------------------------------+
   2033    |                Immediate  15:0                |
   2034    +-----------------------------------------------+
   2035 
   2036    JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
   2037    Note that the immediate value in the first word is swapped.
   2038 
   2039    When producing a relocatable object file, R_MIPS16_26 is
   2040    handled mostly like R_MIPS_26.  In particular, the addend is
   2041    stored as a straight 26-bit value in a 32-bit instruction.
   2042    (gas makes life simpler for itself by never adjusting a
   2043    R_MIPS16_26 reloc to be against a section, so the addend is
   2044    always zero).  However, the 32 bit instruction is stored as 2
   2045    16-bit values, rather than a single 32-bit value.  In a
   2046    big-endian file, the result is the same; in a little-endian
   2047    file, the two 16-bit halves of the 32 bit value are swapped.
   2048    This is so that a disassembler can recognize the jal
   2049    instruction.
   2050 
   2051    When doing a final link, R_MIPS16_26 is treated as a 32 bit
   2052    instruction stored as two 16-bit values.  The addend A is the
   2053    contents of the targ26 field.  The calculation is the same as
   2054    R_MIPS_26.  When storing the calculated value, reorder the
   2055    immediate value as shown above, and don't forget to store the
   2056    value as two 16-bit values.
   2057 
   2058    To put it in MIPS ABI terms, the relocation field is T-targ26-16,
   2059    defined as
   2060 
   2061    big-endian:
   2062    +--------+----------------------+
   2063    |        |                      |
   2064    |        |    targ26-16         |
   2065    |31    26|25                   0|
   2066    +--------+----------------------+
   2067 
   2068    little-endian:
   2069    +----------+------+-------------+
   2070    |          |      |             |
   2071    |  sub1    |      |     sub2    |
   2072    |0        9|10  15|16         31|
   2073    +----------+--------------------+
   2074    where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
   2075    ((sub1 << 16) | sub2)).
   2076 
   2077    When producing a relocatable object file, the calculation is
   2078    (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
   2079    When producing a fully linked file, the calculation is
   2080    let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
   2081    ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
   2082 
   2083    The table below lists the other MIPS16 instruction relocations.
   2084    Each one is calculated in the same way as the non-MIPS16 relocation
   2085    given on the right, but using the extended MIPS16 layout of 16-bit
   2086    immediate fields:
   2087 
   2088 	R_MIPS16_GPREL		R_MIPS_GPREL16
   2089 	R_MIPS16_GOT16		R_MIPS_GOT16
   2090 	R_MIPS16_CALL16		R_MIPS_CALL16
   2091 	R_MIPS16_HI16		R_MIPS_HI16
   2092 	R_MIPS16_LO16		R_MIPS_LO16
   2093 
   2094    A typical instruction will have a format like this:
   2095 
   2096    +--------------+--------------------------------+
   2097    |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
   2098    +--------------+--------------------------------+
   2099    |    Major     |   rx   |   ry   |   Imm  4:0   |
   2100    +--------------+--------------------------------+
   2101 
   2102    EXTEND is the five bit value 11110.  Major is the instruction
   2103    opcode.
   2104 
   2105    All we need to do here is shuffle the bits appropriately.
   2106    As above, the two 16-bit halves must be swapped on a
   2107    little-endian system.  */
   2108 
   2109 static inline bfd_boolean
   2110 mips16_reloc_p (int r_type)
   2111 {
   2112   switch (r_type)
   2113     {
   2114     case R_MIPS16_26:
   2115     case R_MIPS16_GPREL:
   2116     case R_MIPS16_GOT16:
   2117     case R_MIPS16_CALL16:
   2118     case R_MIPS16_HI16:
   2119     case R_MIPS16_LO16:
   2120     case R_MIPS16_TLS_GD:
   2121     case R_MIPS16_TLS_LDM:
   2122     case R_MIPS16_TLS_DTPREL_HI16:
   2123     case R_MIPS16_TLS_DTPREL_LO16:
   2124     case R_MIPS16_TLS_GOTTPREL:
   2125     case R_MIPS16_TLS_TPREL_HI16:
   2126     case R_MIPS16_TLS_TPREL_LO16:
   2127       return TRUE;
   2128 
   2129     default:
   2130       return FALSE;
   2131     }
   2132 }
   2133 
   2134 /* Check if a microMIPS reloc.  */
   2135 
   2136 static inline bfd_boolean
   2137 micromips_reloc_p (unsigned int r_type)
   2138 {
   2139   return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
   2140 }
   2141 
   2142 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
   2143    on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
   2144    and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.  */
   2145 
   2146 static inline bfd_boolean
   2147 micromips_reloc_shuffle_p (unsigned int r_type)
   2148 {
   2149   return (micromips_reloc_p (r_type)
   2150 	  && r_type != R_MICROMIPS_PC7_S1
   2151 	  && r_type != R_MICROMIPS_PC10_S1);
   2152 }
   2153 
   2154 static inline bfd_boolean
   2155 got16_reloc_p (int r_type)
   2156 {
   2157   return (r_type == R_MIPS_GOT16
   2158 	  || r_type == R_MIPS16_GOT16
   2159 	  || r_type == R_MICROMIPS_GOT16);
   2160 }
   2161 
   2162 static inline bfd_boolean
   2163 call16_reloc_p (int r_type)
   2164 {
   2165   return (r_type == R_MIPS_CALL16
   2166 	  || r_type == R_MIPS16_CALL16
   2167 	  || r_type == R_MICROMIPS_CALL16);
   2168 }
   2169 
   2170 static inline bfd_boolean
   2171 got_disp_reloc_p (unsigned int r_type)
   2172 {
   2173   return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
   2174 }
   2175 
   2176 static inline bfd_boolean
   2177 got_page_reloc_p (unsigned int r_type)
   2178 {
   2179   return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
   2180 }
   2181 
   2182 static inline bfd_boolean
   2183 got_ofst_reloc_p (unsigned int r_type)
   2184 {
   2185   return r_type == R_MIPS_GOT_OFST || r_type == R_MICROMIPS_GOT_OFST;
   2186 }
   2187 
   2188 static inline bfd_boolean
   2189 got_hi16_reloc_p (unsigned int r_type)
   2190 {
   2191   return r_type == R_MIPS_GOT_HI16 || r_type == R_MICROMIPS_GOT_HI16;
   2192 }
   2193 
   2194 static inline bfd_boolean
   2195 got_lo16_reloc_p (unsigned int r_type)
   2196 {
   2197   return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
   2198 }
   2199 
   2200 static inline bfd_boolean
   2201 call_hi16_reloc_p (unsigned int r_type)
   2202 {
   2203   return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
   2204 }
   2205 
   2206 static inline bfd_boolean
   2207 call_lo16_reloc_p (unsigned int r_type)
   2208 {
   2209   return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
   2210 }
   2211 
   2212 static inline bfd_boolean
   2213 hi16_reloc_p (int r_type)
   2214 {
   2215   return (r_type == R_MIPS_HI16
   2216 	  || r_type == R_MIPS16_HI16
   2217 	  || r_type == R_MICROMIPS_HI16
   2218 	  || r_type == R_MIPS_PCHI16);
   2219 }
   2220 
   2221 static inline bfd_boolean
   2222 lo16_reloc_p (int r_type)
   2223 {
   2224   return (r_type == R_MIPS_LO16
   2225 	  || r_type == R_MIPS16_LO16
   2226 	  || r_type == R_MICROMIPS_LO16
   2227 	  || r_type == R_MIPS_PCLO16);
   2228 }
   2229 
   2230 static inline bfd_boolean
   2231 mips16_call_reloc_p (int r_type)
   2232 {
   2233   return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
   2234 }
   2235 
   2236 static inline bfd_boolean
   2237 jal_reloc_p (int r_type)
   2238 {
   2239   return (r_type == R_MIPS_26
   2240 	  || r_type == R_MIPS16_26
   2241 	  || r_type == R_MICROMIPS_26_S1);
   2242 }
   2243 
   2244 static inline bfd_boolean
   2245 aligned_pcrel_reloc_p (int r_type)
   2246 {
   2247   return (r_type == R_MIPS_PC18_S3
   2248 	  || r_type == R_MIPS_PC19_S2);
   2249 }
   2250 
   2251 static inline bfd_boolean
   2252 micromips_branch_reloc_p (int r_type)
   2253 {
   2254   return (r_type == R_MICROMIPS_26_S1
   2255 	  || r_type == R_MICROMIPS_PC16_S1
   2256 	  || r_type == R_MICROMIPS_PC10_S1
   2257 	  || r_type == R_MICROMIPS_PC7_S1);
   2258 }
   2259 
   2260 static inline bfd_boolean
   2261 tls_gd_reloc_p (unsigned int r_type)
   2262 {
   2263   return (r_type == R_MIPS_TLS_GD
   2264 	  || r_type == R_MIPS16_TLS_GD
   2265 	  || r_type == R_MICROMIPS_TLS_GD);
   2266 }
   2267 
   2268 static inline bfd_boolean
   2269 tls_ldm_reloc_p (unsigned int r_type)
   2270 {
   2271   return (r_type == R_MIPS_TLS_LDM
   2272 	  || r_type == R_MIPS16_TLS_LDM
   2273 	  || r_type == R_MICROMIPS_TLS_LDM);
   2274 }
   2275 
   2276 static inline bfd_boolean
   2277 tls_gottprel_reloc_p (unsigned int r_type)
   2278 {
   2279   return (r_type == R_MIPS_TLS_GOTTPREL
   2280 	  || r_type == R_MIPS16_TLS_GOTTPREL
   2281 	  || r_type == R_MICROMIPS_TLS_GOTTPREL);
   2282 }
   2283 
   2284 void
   2285 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
   2286 			       bfd_boolean jal_shuffle, bfd_byte *data)
   2287 {
   2288   bfd_vma first, second, val;
   2289 
   2290   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
   2291     return;
   2292 
   2293   /* Pick up the first and second halfwords of the instruction.  */
   2294   first = bfd_get_16 (abfd, data);
   2295   second = bfd_get_16 (abfd, data + 2);
   2296   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
   2297     val = first << 16 | second;
   2298   else if (r_type != R_MIPS16_26)
   2299     val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
   2300 	   | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
   2301   else
   2302     val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
   2303 	   | ((first & 0x1f) << 21) | second);
   2304   bfd_put_32 (abfd, val, data);
   2305 }
   2306 
   2307 void
   2308 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
   2309 			     bfd_boolean jal_shuffle, bfd_byte *data)
   2310 {
   2311   bfd_vma first, second, val;
   2312 
   2313   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
   2314     return;
   2315 
   2316   val = bfd_get_32 (abfd, data);
   2317   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
   2318     {
   2319       second = val & 0xffff;
   2320       first = val >> 16;
   2321     }
   2322   else if (r_type != R_MIPS16_26)
   2323     {
   2324       second = ((val >> 11) & 0xffe0) | (val & 0x1f);
   2325       first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
   2326     }
   2327   else
   2328     {
   2329       second = val & 0xffff;
   2330       first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
   2331 	       | ((val >> 21) & 0x1f);
   2332     }
   2333   bfd_put_16 (abfd, second, data + 2);
   2334   bfd_put_16 (abfd, first, data);
   2335 }
   2336 
   2337 bfd_reloc_status_type
   2338 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
   2339 			       arelent *reloc_entry, asection *input_section,
   2340 			       bfd_boolean relocatable, void *data, bfd_vma gp)
   2341 {
   2342   bfd_vma relocation;
   2343   bfd_signed_vma val;
   2344   bfd_reloc_status_type status;
   2345 
   2346   if (bfd_is_com_section (symbol->section))
   2347     relocation = 0;
   2348   else
   2349     relocation = symbol->value;
   2350 
   2351   relocation += symbol->section->output_section->vma;
   2352   relocation += symbol->section->output_offset;
   2353 
   2354   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
   2355     return bfd_reloc_outofrange;
   2356 
   2357   /* Set val to the offset into the section or symbol.  */
   2358   val = reloc_entry->addend;
   2359 
   2360   _bfd_mips_elf_sign_extend (val, 16);
   2361 
   2362   /* Adjust val for the final section location and GP value.  If we
   2363      are producing relocatable output, we don't want to do this for
   2364      an external symbol.  */
   2365   if (! relocatable
   2366       || (symbol->flags & BSF_SECTION_SYM) != 0)
   2367     val += relocation - gp;
   2368 
   2369   if (reloc_entry->howto->partial_inplace)
   2370     {
   2371       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
   2372 				       (bfd_byte *) data
   2373 				       + reloc_entry->address);
   2374       if (status != bfd_reloc_ok)
   2375 	return status;
   2376     }
   2377   else
   2378     reloc_entry->addend = val;
   2379 
   2380   if (relocatable)
   2381     reloc_entry->address += input_section->output_offset;
   2382 
   2383   return bfd_reloc_ok;
   2384 }
   2385 
   2386 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
   2387    R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
   2388    that contains the relocation field and DATA points to the start of
   2389    INPUT_SECTION.  */
   2390 
   2391 struct mips_hi16
   2392 {
   2393   struct mips_hi16 *next;
   2394   bfd_byte *data;
   2395   asection *input_section;
   2396   arelent rel;
   2397 };
   2398 
   2399 /* FIXME: This should not be a static variable.  */
   2400 
   2401 static struct mips_hi16 *mips_hi16_list;
   2402 
   2403 /* A howto special_function for REL *HI16 relocations.  We can only
   2404    calculate the correct value once we've seen the partnering
   2405    *LO16 relocation, so just save the information for later.
   2406 
   2407    The ABI requires that the *LO16 immediately follow the *HI16.
   2408    However, as a GNU extension, we permit an arbitrary number of
   2409    *HI16s to be associated with a single *LO16.  This significantly
   2410    simplies the relocation handling in gcc.  */
   2411 
   2412 bfd_reloc_status_type
   2413 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
   2414 			  asymbol *symbol ATTRIBUTE_UNUSED, void *data,
   2415 			  asection *input_section, bfd *output_bfd,
   2416 			  char **error_message ATTRIBUTE_UNUSED)
   2417 {
   2418   struct mips_hi16 *n;
   2419 
   2420   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
   2421     return bfd_reloc_outofrange;
   2422 
   2423   n = bfd_malloc (sizeof *n);
   2424   if (n == NULL)
   2425     return bfd_reloc_outofrange;
   2426 
   2427   n->next = mips_hi16_list;
   2428   n->data = data;
   2429   n->input_section = input_section;
   2430   n->rel = *reloc_entry;
   2431   mips_hi16_list = n;
   2432 
   2433   if (output_bfd != NULL)
   2434     reloc_entry->address += input_section->output_offset;
   2435 
   2436   return bfd_reloc_ok;
   2437 }
   2438 
   2439 /* A howto special_function for REL R_MIPS*_GOT16 relocations.  This is just
   2440    like any other 16-bit relocation when applied to global symbols, but is
   2441    treated in the same as R_MIPS_HI16 when applied to local symbols.  */
   2442 
   2443 bfd_reloc_status_type
   2444 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
   2445 			   void *data, asection *input_section,
   2446 			   bfd *output_bfd, char **error_message)
   2447 {
   2448   if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
   2449       || bfd_is_und_section (bfd_get_section (symbol))
   2450       || bfd_is_com_section (bfd_get_section (symbol)))
   2451     /* The relocation is against a global symbol.  */
   2452     return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
   2453 					input_section, output_bfd,
   2454 					error_message);
   2455 
   2456   return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
   2457 				   input_section, output_bfd, error_message);
   2458 }
   2459 
   2460 /* A howto special_function for REL *LO16 relocations.  The *LO16 itself
   2461    is a straightforward 16 bit inplace relocation, but we must deal with
   2462    any partnering high-part relocations as well.  */
   2463 
   2464 bfd_reloc_status_type
   2465 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
   2466 			  void *data, asection *input_section,
   2467 			  bfd *output_bfd, char **error_message)
   2468 {
   2469   bfd_vma vallo;
   2470   bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
   2471 
   2472   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
   2473     return bfd_reloc_outofrange;
   2474 
   2475   _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
   2476 				 location);
   2477   vallo = bfd_get_32 (abfd, location);
   2478   _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
   2479 			       location);
   2480 
   2481   while (mips_hi16_list != NULL)
   2482     {
   2483       bfd_reloc_status_type ret;
   2484       struct mips_hi16 *hi;
   2485 
   2486       hi = mips_hi16_list;
   2487 
   2488       /* R_MIPS*_GOT16 relocations are something of a special case.  We
   2489 	 want to install the addend in the same way as for a R_MIPS*_HI16
   2490 	 relocation (with a rightshift of 16).  However, since GOT16
   2491 	 relocations can also be used with global symbols, their howto
   2492 	 has a rightshift of 0.  */
   2493       if (hi->rel.howto->type == R_MIPS_GOT16)
   2494 	hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
   2495       else if (hi->rel.howto->type == R_MIPS16_GOT16)
   2496 	hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
   2497       else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
   2498 	hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
   2499 
   2500       /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
   2501 	 carry or borrow will induce a change of +1 or -1 in the high part.  */
   2502       hi->rel.addend += (vallo + 0x8000) & 0xffff;
   2503 
   2504       ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
   2505 					 hi->input_section, output_bfd,
   2506 					 error_message);
   2507       if (ret != bfd_reloc_ok)
   2508 	return ret;
   2509 
   2510       mips_hi16_list = hi->next;
   2511       free (hi);
   2512     }
   2513 
   2514   return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
   2515 				      input_section, output_bfd,
   2516 				      error_message);
   2517 }
   2518 
   2519 /* A generic howto special_function.  This calculates and installs the
   2520    relocation itself, thus avoiding the oft-discussed problems in
   2521    bfd_perform_relocation and bfd_install_relocation.  */
   2522 
   2523 bfd_reloc_status_type
   2524 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
   2525 			     asymbol *symbol, void *data ATTRIBUTE_UNUSED,
   2526 			     asection *input_section, bfd *output_bfd,
   2527 			     char **error_message ATTRIBUTE_UNUSED)
   2528 {
   2529   bfd_signed_vma val;
   2530   bfd_reloc_status_type status;
   2531   bfd_boolean relocatable;
   2532 
   2533   relocatable = (output_bfd != NULL);
   2534 
   2535   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
   2536     return bfd_reloc_outofrange;
   2537 
   2538   /* Build up the field adjustment in VAL.  */
   2539   val = 0;
   2540   if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
   2541     {
   2542       /* Either we're calculating the final field value or we have a
   2543 	 relocation against a section symbol.  Add in the section's
   2544 	 offset or address.  */
   2545       val += symbol->section->output_section->vma;
   2546       val += symbol->section->output_offset;
   2547     }
   2548 
   2549   if (!relocatable)
   2550     {
   2551       /* We're calculating the final field value.  Add in the symbol's value
   2552 	 and, if pc-relative, subtract the address of the field itself.  */
   2553       val += symbol->value;
   2554       if (reloc_entry->howto->pc_relative)
   2555 	{
   2556 	  val -= input_section->output_section->vma;
   2557 	  val -= input_section->output_offset;
   2558 	  val -= reloc_entry->address;
   2559 	}
   2560     }
   2561 
   2562   /* VAL is now the final adjustment.  If we're keeping this relocation
   2563      in the output file, and if the relocation uses a separate addend,
   2564      we just need to add VAL to that addend.  Otherwise we need to add
   2565      VAL to the relocation field itself.  */
   2566   if (relocatable && !reloc_entry->howto->partial_inplace)
   2567     reloc_entry->addend += val;
   2568   else
   2569     {
   2570       bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
   2571 
   2572       /* Add in the separate addend, if any.  */
   2573       val += reloc_entry->addend;
   2574 
   2575       /* Add VAL to the relocation field.  */
   2576       _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
   2577 				     location);
   2578       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
   2579 				       location);
   2580       _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
   2581 				   location);
   2582 
   2583       if (status != bfd_reloc_ok)
   2584 	return status;
   2585     }
   2586 
   2587   if (relocatable)
   2588     reloc_entry->address += input_section->output_offset;
   2589 
   2590   return bfd_reloc_ok;
   2591 }
   2592 
   2593 /* Swap an entry in a .gptab section.  Note that these routines rely
   2595    on the equivalence of the two elements of the union.  */
   2596 
   2597 static void
   2598 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
   2599 			      Elf32_gptab *in)
   2600 {
   2601   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
   2602   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
   2603 }
   2604 
   2605 static void
   2606 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
   2607 			       Elf32_External_gptab *ex)
   2608 {
   2609   H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
   2610   H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
   2611 }
   2612 
   2613 static void
   2614 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
   2615 				Elf32_External_compact_rel *ex)
   2616 {
   2617   H_PUT_32 (abfd, in->id1, ex->id1);
   2618   H_PUT_32 (abfd, in->num, ex->num);
   2619   H_PUT_32 (abfd, in->id2, ex->id2);
   2620   H_PUT_32 (abfd, in->offset, ex->offset);
   2621   H_PUT_32 (abfd, in->reserved0, ex->reserved0);
   2622   H_PUT_32 (abfd, in->reserved1, ex->reserved1);
   2623 }
   2624 
   2625 static void
   2626 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
   2627 			   Elf32_External_crinfo *ex)
   2628 {
   2629   unsigned long l;
   2630 
   2631   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
   2632        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
   2633        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
   2634        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
   2635   H_PUT_32 (abfd, l, ex->info);
   2636   H_PUT_32 (abfd, in->konst, ex->konst);
   2637   H_PUT_32 (abfd, in->vaddr, ex->vaddr);
   2638 }
   2639 
   2640 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
   2642    routines swap this structure in and out.  They are used outside of
   2643    BFD, so they are globally visible.  */
   2644 
   2645 void
   2646 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
   2647 				Elf32_RegInfo *in)
   2648 {
   2649   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
   2650   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
   2651   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
   2652   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
   2653   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
   2654   in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
   2655 }
   2656 
   2657 void
   2658 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
   2659 				 Elf32_External_RegInfo *ex)
   2660 {
   2661   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
   2662   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
   2663   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
   2664   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
   2665   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
   2666   H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
   2667 }
   2668 
   2669 /* In the 64 bit ABI, the .MIPS.options section holds register
   2670    information in an Elf64_Reginfo structure.  These routines swap
   2671    them in and out.  They are globally visible because they are used
   2672    outside of BFD.  These routines are here so that gas can call them
   2673    without worrying about whether the 64 bit ABI has been included.  */
   2674 
   2675 void
   2676 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
   2677 				Elf64_Internal_RegInfo *in)
   2678 {
   2679   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
   2680   in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
   2681   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
   2682   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
   2683   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
   2684   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
   2685   in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
   2686 }
   2687 
   2688 void
   2689 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
   2690 				 Elf64_External_RegInfo *ex)
   2691 {
   2692   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
   2693   H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
   2694   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
   2695   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
   2696   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
   2697   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
   2698   H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
   2699 }
   2700 
   2701 /* Swap in an options header.  */
   2702 
   2703 void
   2704 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
   2705 			      Elf_Internal_Options *in)
   2706 {
   2707   in->kind = H_GET_8 (abfd, ex->kind);
   2708   in->size = H_GET_8 (abfd, ex->size);
   2709   in->section = H_GET_16 (abfd, ex->section);
   2710   in->info = H_GET_32 (abfd, ex->info);
   2711 }
   2712 
   2713 /* Swap out an options header.  */
   2714 
   2715 void
   2716 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
   2717 			       Elf_External_Options *ex)
   2718 {
   2719   H_PUT_8 (abfd, in->kind, ex->kind);
   2720   H_PUT_8 (abfd, in->size, ex->size);
   2721   H_PUT_16 (abfd, in->section, ex->section);
   2722   H_PUT_32 (abfd, in->info, ex->info);
   2723 }
   2724 
   2725 /* Swap in an abiflags structure.  */
   2726 
   2727 void
   2728 bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd,
   2729 				  const Elf_External_ABIFlags_v0 *ex,
   2730 				  Elf_Internal_ABIFlags_v0 *in)
   2731 {
   2732   in->version = H_GET_16 (abfd, ex->version);
   2733   in->isa_level = H_GET_8 (abfd, ex->isa_level);
   2734   in->isa_rev = H_GET_8 (abfd, ex->isa_rev);
   2735   in->gpr_size = H_GET_8 (abfd, ex->gpr_size);
   2736   in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size);
   2737   in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size);
   2738   in->fp_abi = H_GET_8 (abfd, ex->fp_abi);
   2739   in->isa_ext = H_GET_32 (abfd, ex->isa_ext);
   2740   in->ases = H_GET_32 (abfd, ex->ases);
   2741   in->flags1 = H_GET_32 (abfd, ex->flags1);
   2742   in->flags2 = H_GET_32 (abfd, ex->flags2);
   2743 }
   2744 
   2745 /* Swap out an abiflags structure.  */
   2746 
   2747 void
   2748 bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd,
   2749 				   const Elf_Internal_ABIFlags_v0 *in,
   2750 				   Elf_External_ABIFlags_v0 *ex)
   2751 {
   2752   H_PUT_16 (abfd, in->version, ex->version);
   2753   H_PUT_8 (abfd, in->isa_level, ex->isa_level);
   2754   H_PUT_8 (abfd, in->isa_rev, ex->isa_rev);
   2755   H_PUT_8 (abfd, in->gpr_size, ex->gpr_size);
   2756   H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size);
   2757   H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size);
   2758   H_PUT_8 (abfd, in->fp_abi, ex->fp_abi);
   2759   H_PUT_32 (abfd, in->isa_ext, ex->isa_ext);
   2760   H_PUT_32 (abfd, in->ases, ex->ases);
   2761   H_PUT_32 (abfd, in->flags1, ex->flags1);
   2762   H_PUT_32 (abfd, in->flags2, ex->flags2);
   2763 }
   2764 
   2765 /* This function is called via qsort() to sort the dynamic relocation
   2767    entries by increasing r_symndx value.  */
   2768 
   2769 static int
   2770 sort_dynamic_relocs (const void *arg1, const void *arg2)
   2771 {
   2772   Elf_Internal_Rela int_reloc1;
   2773   Elf_Internal_Rela int_reloc2;
   2774   int diff;
   2775 
   2776   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
   2777   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
   2778 
   2779   diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
   2780   if (diff != 0)
   2781     return diff;
   2782 
   2783   if (int_reloc1.r_offset < int_reloc2.r_offset)
   2784     return -1;
   2785   if (int_reloc1.r_offset > int_reloc2.r_offset)
   2786     return 1;
   2787   return 0;
   2788 }
   2789 
   2790 /* Like sort_dynamic_relocs, but used for elf64 relocations.  */
   2791 
   2792 static int
   2793 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
   2794 			const void *arg2 ATTRIBUTE_UNUSED)
   2795 {
   2796 #ifdef BFD64
   2797   Elf_Internal_Rela int_reloc1[3];
   2798   Elf_Internal_Rela int_reloc2[3];
   2799 
   2800   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
   2801     (reldyn_sorting_bfd, arg1, int_reloc1);
   2802   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
   2803     (reldyn_sorting_bfd, arg2, int_reloc2);
   2804 
   2805   if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
   2806     return -1;
   2807   if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
   2808     return 1;
   2809 
   2810   if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
   2811     return -1;
   2812   if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
   2813     return 1;
   2814   return 0;
   2815 #else
   2816   abort ();
   2817 #endif
   2818 }
   2819 
   2820 
   2821 /* This routine is used to write out ECOFF debugging external symbol
   2822    information.  It is called via mips_elf_link_hash_traverse.  The
   2823    ECOFF external symbol information must match the ELF external
   2824    symbol information.  Unfortunately, at this point we don't know
   2825    whether a symbol is required by reloc information, so the two
   2826    tables may wind up being different.  We must sort out the external
   2827    symbol information before we can set the final size of the .mdebug
   2828    section, and we must set the size of the .mdebug section before we
   2829    can relocate any sections, and we can't know which symbols are
   2830    required by relocation until we relocate the sections.
   2831    Fortunately, it is relatively unlikely that any symbol will be
   2832    stripped but required by a reloc.  In particular, it can not happen
   2833    when generating a final executable.  */
   2834 
   2835 static bfd_boolean
   2836 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
   2837 {
   2838   struct extsym_info *einfo = data;
   2839   bfd_boolean strip;
   2840   asection *sec, *output_section;
   2841 
   2842   if (h->root.indx == -2)
   2843     strip = FALSE;
   2844   else if ((h->root.def_dynamic
   2845 	    || h->root.ref_dynamic
   2846 	    || h->root.type == bfd_link_hash_new)
   2847 	   && !h->root.def_regular
   2848 	   && !h->root.ref_regular)
   2849     strip = TRUE;
   2850   else if (einfo->info->strip == strip_all
   2851 	   || (einfo->info->strip == strip_some
   2852 	       && bfd_hash_lookup (einfo->info->keep_hash,
   2853 				   h->root.root.root.string,
   2854 				   FALSE, FALSE) == NULL))
   2855     strip = TRUE;
   2856   else
   2857     strip = FALSE;
   2858 
   2859   if (strip)
   2860     return TRUE;
   2861 
   2862   if (h->esym.ifd == -2)
   2863     {
   2864       h->esym.jmptbl = 0;
   2865       h->esym.cobol_main = 0;
   2866       h->esym.weakext = 0;
   2867       h->esym.reserved = 0;
   2868       h->esym.ifd = ifdNil;
   2869       h->esym.asym.value = 0;
   2870       h->esym.asym.st = stGlobal;
   2871 
   2872       if (h->root.root.type == bfd_link_hash_undefined
   2873 	  || h->root.root.type == bfd_link_hash_undefweak)
   2874 	{
   2875 	  const char *name;
   2876 
   2877 	  /* Use undefined class.  Also, set class and type for some
   2878              special symbols.  */
   2879 	  name = h->root.root.root.string;
   2880 	  if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
   2881 	      || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
   2882 	    {
   2883 	      h->esym.asym.sc = scData;
   2884 	      h->esym.asym.st = stLabel;
   2885 	      h->esym.asym.value = 0;
   2886 	    }
   2887 	  else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
   2888 	    {
   2889 	      h->esym.asym.sc = scAbs;
   2890 	      h->esym.asym.st = stLabel;
   2891 	      h->esym.asym.value =
   2892 		mips_elf_hash_table (einfo->info)->procedure_count;
   2893 	    }
   2894 	  else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
   2895 	    {
   2896 	      h->esym.asym.sc = scAbs;
   2897 	      h->esym.asym.st = stLabel;
   2898 	      h->esym.asym.value = elf_gp (einfo->abfd);
   2899 	    }
   2900 	  else
   2901 	    h->esym.asym.sc = scUndefined;
   2902 	}
   2903       else if (h->root.root.type != bfd_link_hash_defined
   2904 	  && h->root.root.type != bfd_link_hash_defweak)
   2905 	h->esym.asym.sc = scAbs;
   2906       else
   2907 	{
   2908 	  const char *name;
   2909 
   2910 	  sec = h->root.root.u.def.section;
   2911 	  output_section = sec->output_section;
   2912 
   2913 	  /* When making a shared library and symbol h is the one from
   2914 	     the another shared library, OUTPUT_SECTION may be null.  */
   2915 	  if (output_section == NULL)
   2916 	    h->esym.asym.sc = scUndefined;
   2917 	  else
   2918 	    {
   2919 	      name = bfd_section_name (output_section->owner, output_section);
   2920 
   2921 	      if (strcmp (name, ".text") == 0)
   2922 		h->esym.asym.sc = scText;
   2923 	      else if (strcmp (name, ".data") == 0)
   2924 		h->esym.asym.sc = scData;
   2925 	      else if (strcmp (name, ".sdata") == 0)
   2926 		h->esym.asym.sc = scSData;
   2927 	      else if (strcmp (name, ".rodata") == 0
   2928 		       || strcmp (name, ".rdata") == 0)
   2929 		h->esym.asym.sc = scRData;
   2930 	      else if (strcmp (name, ".bss") == 0)
   2931 		h->esym.asym.sc = scBss;
   2932 	      else if (strcmp (name, ".sbss") == 0)
   2933 		h->esym.asym.sc = scSBss;
   2934 	      else if (strcmp (name, ".init") == 0)
   2935 		h->esym.asym.sc = scInit;
   2936 	      else if (strcmp (name, ".fini") == 0)
   2937 		h->esym.asym.sc = scFini;
   2938 	      else
   2939 		h->esym.asym.sc = scAbs;
   2940 	    }
   2941 	}
   2942 
   2943       h->esym.asym.reserved = 0;
   2944       h->esym.asym.index = indexNil;
   2945     }
   2946 
   2947   if (h->root.root.type == bfd_link_hash_common)
   2948     h->esym.asym.value = h->root.root.u.c.size;
   2949   else if (h->root.root.type == bfd_link_hash_defined
   2950 	   || h->root.root.type == bfd_link_hash_defweak)
   2951     {
   2952       if (h->esym.asym.sc == scCommon)
   2953 	h->esym.asym.sc = scBss;
   2954       else if (h->esym.asym.sc == scSCommon)
   2955 	h->esym.asym.sc = scSBss;
   2956 
   2957       sec = h->root.root.u.def.section;
   2958       output_section = sec->output_section;
   2959       if (output_section != NULL)
   2960 	h->esym.asym.value = (h->root.root.u.def.value
   2961 			      + sec->output_offset
   2962 			      + output_section->vma);
   2963       else
   2964 	h->esym.asym.value = 0;
   2965     }
   2966   else
   2967     {
   2968       struct mips_elf_link_hash_entry *hd = h;
   2969 
   2970       while (hd->root.root.type == bfd_link_hash_indirect)
   2971 	hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
   2972 
   2973       if (hd->needs_lazy_stub)
   2974 	{
   2975 	  BFD_ASSERT (hd->root.plt.plist != NULL);
   2976 	  BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE);
   2977 	  /* Set type and value for a symbol with a function stub.  */
   2978 	  h->esym.asym.st = stProc;
   2979 	  sec = hd->root.root.u.def.section;
   2980 	  if (sec == NULL)
   2981 	    h->esym.asym.value = 0;
   2982 	  else
   2983 	    {
   2984 	      output_section = sec->output_section;
   2985 	      if (output_section != NULL)
   2986 		h->esym.asym.value = (hd->root.plt.plist->stub_offset
   2987 				      + sec->output_offset
   2988 				      + output_section->vma);
   2989 	      else
   2990 		h->esym.asym.value = 0;
   2991 	    }
   2992 	}
   2993     }
   2994 
   2995   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
   2996 				      h->root.root.root.string,
   2997 				      &h->esym))
   2998     {
   2999       einfo->failed = TRUE;
   3000       return FALSE;
   3001     }
   3002 
   3003   return TRUE;
   3004 }
   3005 
   3006 /* A comparison routine used to sort .gptab entries.  */
   3007 
   3008 static int
   3009 gptab_compare (const void *p1, const void *p2)
   3010 {
   3011   const Elf32_gptab *a1 = p1;
   3012   const Elf32_gptab *a2 = p2;
   3013 
   3014   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
   3015 }
   3016 
   3017 /* Functions to manage the got entry hash table.  */
   3019 
   3020 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
   3021    hash number.  */
   3022 
   3023 static INLINE hashval_t
   3024 mips_elf_hash_bfd_vma (bfd_vma addr)
   3025 {
   3026 #ifdef BFD64
   3027   return addr + (addr >> 32);
   3028 #else
   3029   return addr;
   3030 #endif
   3031 }
   3032 
   3033 static hashval_t
   3034 mips_elf_got_entry_hash (const void *entry_)
   3035 {
   3036   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
   3037 
   3038   return (entry->symndx
   3039 	  + ((entry->tls_type == GOT_TLS_LDM) << 18)
   3040 	  + (entry->tls_type == GOT_TLS_LDM ? 0
   3041 	     : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
   3042 	     : entry->symndx >= 0 ? (entry->abfd->id
   3043 				     + mips_elf_hash_bfd_vma (entry->d.addend))
   3044 	     : entry->d.h->root.root.root.hash));
   3045 }
   3046 
   3047 static int
   3048 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
   3049 {
   3050   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
   3051   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
   3052 
   3053   return (e1->symndx == e2->symndx
   3054 	  && e1->tls_type == e2->tls_type
   3055 	  && (e1->tls_type == GOT_TLS_LDM ? TRUE
   3056 	      : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address
   3057 	      : e1->symndx >= 0 ? (e1->abfd == e2->abfd
   3058 				   && e1->d.addend == e2->d.addend)
   3059 	      : e2->abfd && e1->d.h == e2->d.h));
   3060 }
   3061 
   3062 static hashval_t
   3063 mips_got_page_ref_hash (const void *ref_)
   3064 {
   3065   const struct mips_got_page_ref *ref;
   3066 
   3067   ref = (const struct mips_got_page_ref *) ref_;
   3068   return ((ref->symndx >= 0
   3069 	   ? (hashval_t) (ref->u.abfd->id + ref->symndx)
   3070 	   : ref->u.h->root.root.root.hash)
   3071 	  + mips_elf_hash_bfd_vma (ref->addend));
   3072 }
   3073 
   3074 static int
   3075 mips_got_page_ref_eq (const void *ref1_, const void *ref2_)
   3076 {
   3077   const struct mips_got_page_ref *ref1, *ref2;
   3078 
   3079   ref1 = (const struct mips_got_page_ref *) ref1_;
   3080   ref2 = (const struct mips_got_page_ref *) ref2_;
   3081   return (ref1->symndx == ref2->symndx
   3082 	  && (ref1->symndx < 0
   3083 	      ? ref1->u.h == ref2->u.h
   3084 	      : ref1->u.abfd == ref2->u.abfd)
   3085 	  && ref1->addend == ref2->addend);
   3086 }
   3087 
   3088 static hashval_t
   3089 mips_got_page_entry_hash (const void *entry_)
   3090 {
   3091   const struct mips_got_page_entry *entry;
   3092 
   3093   entry = (const struct mips_got_page_entry *) entry_;
   3094   return entry->sec->id;
   3095 }
   3096 
   3097 static int
   3098 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
   3099 {
   3100   const struct mips_got_page_entry *entry1, *entry2;
   3101 
   3102   entry1 = (const struct mips_got_page_entry *) entry1_;
   3103   entry2 = (const struct mips_got_page_entry *) entry2_;
   3104   return entry1->sec == entry2->sec;
   3105 }
   3106 
   3107 /* Create and return a new mips_got_info structure.  */
   3109 
   3110 static struct mips_got_info *
   3111 mips_elf_create_got_info (bfd *abfd)
   3112 {
   3113   struct mips_got_info *g;
   3114 
   3115   g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
   3116   if (g == NULL)
   3117     return NULL;
   3118 
   3119   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
   3120 				    mips_elf_got_entry_eq, NULL);
   3121   if (g->got_entries == NULL)
   3122     return NULL;
   3123 
   3124   g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash,
   3125 				      mips_got_page_ref_eq, NULL);
   3126   if (g->got_page_refs == NULL)
   3127     return NULL;
   3128 
   3129   return g;
   3130 }
   3131 
   3132 /* Return the GOT info for input bfd ABFD, trying to create a new one if
   3133    CREATE_P and if ABFD doesn't already have a GOT.  */
   3134 
   3135 static struct mips_got_info *
   3136 mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p)
   3137 {
   3138   struct mips_elf_obj_tdata *tdata;
   3139 
   3140   if (!is_mips_elf (abfd))
   3141     return NULL;
   3142 
   3143   tdata = mips_elf_tdata (abfd);
   3144   if (!tdata->got && create_p)
   3145     tdata->got = mips_elf_create_got_info (abfd);
   3146   return tdata->got;
   3147 }
   3148 
   3149 /* Record that ABFD should use output GOT G.  */
   3150 
   3151 static void
   3152 mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g)
   3153 {
   3154   struct mips_elf_obj_tdata *tdata;
   3155 
   3156   BFD_ASSERT (is_mips_elf (abfd));
   3157   tdata = mips_elf_tdata (abfd);
   3158   if (tdata->got)
   3159     {
   3160       /* The GOT structure itself and the hash table entries are
   3161 	 allocated to a bfd, but the hash tables aren't.  */
   3162       htab_delete (tdata->got->got_entries);
   3163       htab_delete (tdata->got->got_page_refs);
   3164       if (tdata->got->got_page_entries)
   3165 	htab_delete (tdata->got->got_page_entries);
   3166     }
   3167   tdata->got = g;
   3168 }
   3169 
   3170 /* Return the dynamic relocation section.  If it doesn't exist, try to
   3171    create a new it if CREATE_P, otherwise return NULL.  Also return NULL
   3172    if creation fails.  */
   3173 
   3174 static asection *
   3175 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
   3176 {
   3177   const char *dname;
   3178   asection *sreloc;
   3179   bfd *dynobj;
   3180 
   3181   dname = MIPS_ELF_REL_DYN_NAME (info);
   3182   dynobj = elf_hash_table (info)->dynobj;
   3183   sreloc = bfd_get_linker_section (dynobj, dname);
   3184   if (sreloc == NULL && create_p)
   3185     {
   3186       sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
   3187 						   (SEC_ALLOC
   3188 						    | SEC_LOAD
   3189 						    | SEC_HAS_CONTENTS
   3190 						    | SEC_IN_MEMORY
   3191 						    | SEC_LINKER_CREATED
   3192 						    | SEC_READONLY));
   3193       if (sreloc == NULL
   3194 	  || ! bfd_set_section_alignment (dynobj, sreloc,
   3195 					  MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
   3196 	return NULL;
   3197     }
   3198   return sreloc;
   3199 }
   3200 
   3201 /* Return the GOT_TLS_* type required by relocation type R_TYPE.  */
   3202 
   3203 static int
   3204 mips_elf_reloc_tls_type (unsigned int r_type)
   3205 {
   3206   if (tls_gd_reloc_p (r_type))
   3207     return GOT_TLS_GD;
   3208 
   3209   if (tls_ldm_reloc_p (r_type))
   3210     return GOT_TLS_LDM;
   3211 
   3212   if (tls_gottprel_reloc_p (r_type))
   3213     return GOT_TLS_IE;
   3214 
   3215   return GOT_TLS_NONE;
   3216 }
   3217 
   3218 /* Return the number of GOT slots needed for GOT TLS type TYPE.  */
   3219 
   3220 static int
   3221 mips_tls_got_entries (unsigned int type)
   3222 {
   3223   switch (type)
   3224     {
   3225     case GOT_TLS_GD:
   3226     case GOT_TLS_LDM:
   3227       return 2;
   3228 
   3229     case GOT_TLS_IE:
   3230       return 1;
   3231 
   3232     case GOT_TLS_NONE:
   3233       return 0;
   3234     }
   3235   abort ();
   3236 }
   3237 
   3238 /* Count the number of relocations needed for a TLS GOT entry, with
   3239    access types from TLS_TYPE, and symbol H (or a local symbol if H
   3240    is NULL).  */
   3241 
   3242 static int
   3243 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
   3244 		     struct elf_link_hash_entry *h)
   3245 {
   3246   int indx = 0;
   3247   bfd_boolean need_relocs = FALSE;
   3248   bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
   3249 
   3250   if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
   3251       && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
   3252     indx = h->dynindx;
   3253 
   3254   if ((info->shared || indx != 0)
   3255       && (h == NULL
   3256 	  || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
   3257 	  || h->root.type != bfd_link_hash_undefweak))
   3258     need_relocs = TRUE;
   3259 
   3260   if (!need_relocs)
   3261     return 0;
   3262 
   3263   switch (tls_type)
   3264     {
   3265     case GOT_TLS_GD:
   3266       return indx != 0 ? 2 : 1;
   3267 
   3268     case GOT_TLS_IE:
   3269       return 1;
   3270 
   3271     case GOT_TLS_LDM:
   3272       return info->shared ? 1 : 0;
   3273 
   3274     default:
   3275       return 0;
   3276     }
   3277 }
   3278 
   3279 /* Add the number of GOT entries and TLS relocations required by ENTRY
   3280    to G.  */
   3281 
   3282 static void
   3283 mips_elf_count_got_entry (struct bfd_link_info *info,
   3284 			  struct mips_got_info *g,
   3285 			  struct mips_got_entry *entry)
   3286 {
   3287   if (entry->tls_type)
   3288     {
   3289       g->tls_gotno += mips_tls_got_entries (entry->tls_type);
   3290       g->relocs += mips_tls_got_relocs (info, entry->tls_type,
   3291 					entry->symndx < 0
   3292 					? &entry->d.h->root : NULL);
   3293     }
   3294   else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
   3295     g->local_gotno += 1;
   3296   else
   3297     g->global_gotno += 1;
   3298 }
   3299 
   3300 /* Output a simple dynamic relocation into SRELOC.  */
   3301 
   3302 static void
   3303 mips_elf_output_dynamic_relocation (bfd *output_bfd,
   3304 				    asection *sreloc,
   3305 				    unsigned long reloc_index,
   3306 				    unsigned long indx,
   3307 				    int r_type,
   3308 				    bfd_vma offset)
   3309 {
   3310   Elf_Internal_Rela rel[3];
   3311 
   3312   memset (rel, 0, sizeof (rel));
   3313 
   3314   rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
   3315   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
   3316 
   3317   if (ABI_64_P (output_bfd))
   3318     {
   3319       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
   3320 	(output_bfd, &rel[0],
   3321 	 (sreloc->contents
   3322 	  + reloc_index * sizeof (Elf64_Mips_External_Rel)));
   3323     }
   3324   else
   3325     bfd_elf32_swap_reloc_out
   3326       (output_bfd, &rel[0],
   3327        (sreloc->contents
   3328 	+ reloc_index * sizeof (Elf32_External_Rel)));
   3329 }
   3330 
   3331 /* Initialize a set of TLS GOT entries for one symbol.  */
   3332 
   3333 static void
   3334 mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info,
   3335 			       struct mips_got_entry *entry,
   3336 			       struct mips_elf_link_hash_entry *h,
   3337 			       bfd_vma value)
   3338 {
   3339   struct mips_elf_link_hash_table *htab;
   3340   int indx;
   3341   asection *sreloc, *sgot;
   3342   bfd_vma got_offset, got_offset2;
   3343   bfd_boolean need_relocs = FALSE;
   3344 
   3345   htab = mips_elf_hash_table (info);
   3346   if (htab == NULL)
   3347     return;
   3348 
   3349   sgot = htab->sgot;
   3350 
   3351   indx = 0;
   3352   if (h != NULL)
   3353     {
   3354       bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
   3355 
   3356       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
   3357 	  && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
   3358 	indx = h->root.dynindx;
   3359     }
   3360 
   3361   if (entry->tls_initialized)
   3362     return;
   3363 
   3364   if ((info->shared || indx != 0)
   3365       && (h == NULL
   3366 	  || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
   3367 	  || h->root.type != bfd_link_hash_undefweak))
   3368     need_relocs = TRUE;
   3369 
   3370   /* MINUS_ONE means the symbol is not defined in this object.  It may not
   3371      be defined at all; assume that the value doesn't matter in that
   3372      case.  Otherwise complain if we would use the value.  */
   3373   BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
   3374 	      || h->root.root.type == bfd_link_hash_undefweak);
   3375 
   3376   /* Emit necessary relocations.  */
   3377   sreloc = mips_elf_rel_dyn_section (info, FALSE);
   3378   got_offset = entry->gotidx;
   3379 
   3380   switch (entry->tls_type)
   3381     {
   3382     case GOT_TLS_GD:
   3383       /* General Dynamic.  */
   3384       got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd);
   3385 
   3386       if (need_relocs)
   3387 	{
   3388 	  mips_elf_output_dynamic_relocation
   3389 	    (abfd, sreloc, sreloc->reloc_count++, indx,
   3390 	     ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
   3391 	     sgot->output_offset + sgot->output_section->vma + got_offset);
   3392 
   3393 	  if (indx)
   3394 	    mips_elf_output_dynamic_relocation
   3395 	      (abfd, sreloc, sreloc->reloc_count++, indx,
   3396 	       ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
   3397 	       sgot->output_offset + sgot->output_section->vma + got_offset2);
   3398 	  else
   3399 	    MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
   3400 			       sgot->contents + got_offset2);
   3401 	}
   3402       else
   3403 	{
   3404 	  MIPS_ELF_PUT_WORD (abfd, 1,
   3405 			     sgot->contents + got_offset);
   3406 	  MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
   3407 			     sgot->contents + got_offset2);
   3408 	}
   3409       break;
   3410 
   3411     case GOT_TLS_IE:
   3412       /* Initial Exec model.  */
   3413       if (need_relocs)
   3414 	{
   3415 	  if (indx == 0)
   3416 	    MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
   3417 			       sgot->contents + got_offset);
   3418 	  else
   3419 	    MIPS_ELF_PUT_WORD (abfd, 0,
   3420 			       sgot->contents + got_offset);
   3421 
   3422 	  mips_elf_output_dynamic_relocation
   3423 	    (abfd, sreloc, sreloc->reloc_count++, indx,
   3424 	     ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
   3425 	     sgot->output_offset + sgot->output_section->vma + got_offset);
   3426 	}
   3427       else
   3428 	MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
   3429 			   sgot->contents + got_offset);
   3430       break;
   3431 
   3432     case GOT_TLS_LDM:
   3433       /* The initial offset is zero, and the LD offsets will include the
   3434 	 bias by DTP_OFFSET.  */
   3435       MIPS_ELF_PUT_WORD (abfd, 0,
   3436 			 sgot->contents + got_offset
   3437 			 + MIPS_ELF_GOT_SIZE (abfd));
   3438 
   3439       if (!info->shared)
   3440 	MIPS_ELF_PUT_WORD (abfd, 1,
   3441 			   sgot->contents + got_offset);
   3442       else
   3443 	mips_elf_output_dynamic_relocation
   3444 	  (abfd, sreloc, sreloc->reloc_count++, indx,
   3445 	   ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
   3446 	   sgot->output_offset + sgot->output_section->vma + got_offset);
   3447       break;
   3448 
   3449     default:
   3450       abort ();
   3451     }
   3452 
   3453   entry->tls_initialized = TRUE;
   3454 }
   3455 
   3456 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
   3457    for global symbol H.  .got.plt comes before the GOT, so the offset
   3458    will be negative.  */
   3459 
   3460 static bfd_vma
   3461 mips_elf_gotplt_index (struct bfd_link_info *info,
   3462 		       struct elf_link_hash_entry *h)
   3463 {
   3464   bfd_vma got_address, got_value;
   3465   struct mips_elf_link_hash_table *htab;
   3466 
   3467   htab = mips_elf_hash_table (info);
   3468   BFD_ASSERT (htab != NULL);
   3469 
   3470   BFD_ASSERT (h->plt.plist != NULL);
   3471   BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE);
   3472 
   3473   /* Calculate the address of the associated .got.plt entry.  */
   3474   got_address = (htab->sgotplt->output_section->vma
   3475 		 + htab->sgotplt->output_offset
   3476 		 + (h->plt.plist->gotplt_index
   3477 		    * MIPS_ELF_GOT_SIZE (info->output_bfd)));
   3478 
   3479   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
   3480   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
   3481 	       + htab->root.hgot->root.u.def.section->output_offset
   3482 	       + htab->root.hgot->root.u.def.value);
   3483 
   3484   return got_address - got_value;
   3485 }
   3486 
   3487 /* Return the GOT offset for address VALUE.   If there is not yet a GOT
   3488    entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
   3489    create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
   3490    offset can be found.  */
   3491 
   3492 static bfd_vma
   3493 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
   3494 			  bfd_vma value, unsigned long r_symndx,
   3495 			  struct mips_elf_link_hash_entry *h, int r_type)
   3496 {
   3497   struct mips_elf_link_hash_table *htab;
   3498   struct mips_got_entry *entry;
   3499 
   3500   htab = mips_elf_hash_table (info);
   3501   BFD_ASSERT (htab != NULL);
   3502 
   3503   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
   3504 					   r_symndx, h, r_type);
   3505   if (!entry)
   3506     return MINUS_ONE;
   3507 
   3508   if (entry->tls_type)
   3509     mips_elf_initialize_tls_slots (abfd, info, entry, h, value);
   3510   return entry->gotidx;
   3511 }
   3512 
   3513 /* Return the GOT index of global symbol H in the primary GOT.  */
   3514 
   3515 static bfd_vma
   3516 mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info,
   3517 				   struct elf_link_hash_entry *h)
   3518 {
   3519   struct mips_elf_link_hash_table *htab;
   3520   long global_got_dynindx;
   3521   struct mips_got_info *g;
   3522   bfd_vma got_index;
   3523 
   3524   htab = mips_elf_hash_table (info);
   3525   BFD_ASSERT (htab != NULL);
   3526 
   3527   global_got_dynindx = 0;
   3528   if (htab->global_gotsym != NULL)
   3529     global_got_dynindx = htab->global_gotsym->dynindx;
   3530 
   3531   /* Once we determine the global GOT entry with the lowest dynamic
   3532      symbol table index, we must put all dynamic symbols with greater
   3533      indices into the primary GOT.  That makes it easy to calculate the
   3534      GOT offset.  */
   3535   BFD_ASSERT (h->dynindx >= global_got_dynindx);
   3536   g = mips_elf_bfd_got (obfd, FALSE);
   3537   got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
   3538 	       * MIPS_ELF_GOT_SIZE (obfd));
   3539   BFD_ASSERT (got_index < htab->sgot->size);
   3540 
   3541   return got_index;
   3542 }
   3543 
   3544 /* Return the GOT index for the global symbol indicated by H, which is
   3545    referenced by a relocation of type R_TYPE in IBFD.  */
   3546 
   3547 static bfd_vma
   3548 mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd,
   3549 			   struct elf_link_hash_entry *h, int r_type)
   3550 {
   3551   struct mips_elf_link_hash_table *htab;
   3552   struct mips_got_info *g;
   3553   struct mips_got_entry lookup, *entry;
   3554   bfd_vma gotidx;
   3555 
   3556   htab = mips_elf_hash_table (info);
   3557   BFD_ASSERT (htab != NULL);
   3558 
   3559   g = mips_elf_bfd_got (ibfd, FALSE);
   3560   BFD_ASSERT (g);
   3561 
   3562   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
   3563   if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE))
   3564     return mips_elf_primary_global_got_index (obfd, info, h);
   3565 
   3566   lookup.abfd = ibfd;
   3567   lookup.symndx = -1;
   3568   lookup.d.h = (struct mips_elf_link_hash_entry *) h;
   3569   entry = htab_find (g->got_entries, &lookup);
   3570   BFD_ASSERT (entry);
   3571 
   3572   gotidx = entry->gotidx;
   3573   BFD_ASSERT (gotidx > 0 && gotidx < htab->sgot->size);
   3574 
   3575   if (lookup.tls_type)
   3576     {
   3577       bfd_vma value = MINUS_ONE;
   3578 
   3579       if ((h->root.type == bfd_link_hash_defined
   3580 	   || h->root.type == bfd_link_hash_defweak)
   3581 	  && h->root.u.def.section->output_section)
   3582 	value = (h->root.u.def.value
   3583 		 + h->root.u.def.section->output_offset
   3584 		 + h->root.u.def.section->output_section->vma);
   3585 
   3586       mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value);
   3587     }
   3588   return gotidx;
   3589 }
   3590 
   3591 /* Find a GOT page entry that points to within 32KB of VALUE.  These
   3592    entries are supposed to be placed at small offsets in the GOT, i.e.,
   3593    within 32KB of GP.  Return the index of the GOT entry, or -1 if no
   3594    entry could be created.  If OFFSETP is nonnull, use it to return the
   3595    offset of the GOT entry from VALUE.  */
   3596 
   3597 static bfd_vma
   3598 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
   3599 		   bfd_vma value, bfd_vma *offsetp)
   3600 {
   3601   bfd_vma page, got_index;
   3602   struct mips_got_entry *entry;
   3603 
   3604   page = (value + 0x8000) & ~(bfd_vma) 0xffff;
   3605   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
   3606 					   NULL, R_MIPS_GOT_PAGE);
   3607 
   3608   if (!entry)
   3609     return MINUS_ONE;
   3610 
   3611   got_index = entry->gotidx;
   3612 
   3613   if (offsetp)
   3614     *offsetp = value - entry->d.address;
   3615 
   3616   return got_index;
   3617 }
   3618 
   3619 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
   3620    EXTERNAL is true if the relocation was originally against a global
   3621    symbol that binds locally.  */
   3622 
   3623 static bfd_vma
   3624 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
   3625 		      bfd_vma value, bfd_boolean external)
   3626 {
   3627   struct mips_got_entry *entry;
   3628 
   3629   /* GOT16 relocations against local symbols are followed by a LO16
   3630      relocation; those against global symbols are not.  Thus if the
   3631      symbol was originally local, the GOT16 relocation should load the
   3632      equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
   3633   if (! external)
   3634     value = mips_elf_high (value) << 16;
   3635 
   3636   /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
   3637      R_MIPS16_GOT16, R_MIPS_CALL16, etc.  The format of the entry is the
   3638      same in all cases.  */
   3639   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
   3640 					   NULL, R_MIPS_GOT16);
   3641   if (entry)
   3642     return entry->gotidx;
   3643   else
   3644     return MINUS_ONE;
   3645 }
   3646 
   3647 /* Returns the offset for the entry at the INDEXth position
   3648    in the GOT.  */
   3649 
   3650 static bfd_vma
   3651 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
   3652 				bfd *input_bfd, bfd_vma got_index)
   3653 {
   3654   struct mips_elf_link_hash_table *htab;
   3655   asection *sgot;
   3656   bfd_vma gp;
   3657 
   3658   htab = mips_elf_hash_table (info);
   3659   BFD_ASSERT (htab != NULL);
   3660 
   3661   sgot = htab->sgot;
   3662   gp = _bfd_get_gp_value (output_bfd)
   3663     + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
   3664 
   3665   return sgot->output_section->vma + sgot->output_offset + got_index - gp;
   3666 }
   3667 
   3668 /* Create and return a local GOT entry for VALUE, which was calculated
   3669    from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
   3670    be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
   3671    instead.  */
   3672 
   3673 static struct mips_got_entry *
   3674 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
   3675 				 bfd *ibfd, bfd_vma value,
   3676 				 unsigned long r_symndx,
   3677 				 struct mips_elf_link_hash_entry *h,
   3678 				 int r_type)
   3679 {
   3680   struct mips_got_entry lookup, *entry;
   3681   void **loc;
   3682   struct mips_got_info *g;
   3683   struct mips_elf_link_hash_table *htab;
   3684   bfd_vma gotidx;
   3685 
   3686   htab = mips_elf_hash_table (info);
   3687   BFD_ASSERT (htab != NULL);
   3688 
   3689   g = mips_elf_bfd_got (ibfd, FALSE);
   3690   if (g == NULL)
   3691     {
   3692       g = mips_elf_bfd_got (abfd, FALSE);
   3693       BFD_ASSERT (g != NULL);
   3694     }
   3695 
   3696   /* This function shouldn't be called for symbols that live in the global
   3697      area of the GOT.  */
   3698   BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
   3699 
   3700   lookup.tls_type = mips_elf_reloc_tls_type (r_type);
   3701   if (lookup.tls_type)
   3702     {
   3703       lookup.abfd = ibfd;
   3704       if (tls_ldm_reloc_p (r_type))
   3705 	{
   3706 	  lookup.symndx = 0;
   3707 	  lookup.d.addend = 0;
   3708 	}
   3709       else if (h == NULL)
   3710 	{
   3711 	  lookup.symndx = r_symndx;
   3712 	  lookup.d.addend = 0;
   3713 	}
   3714       else
   3715 	{
   3716 	  lookup.symndx = -1;
   3717 	  lookup.d.h = h;
   3718 	}
   3719 
   3720       entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup);
   3721       BFD_ASSERT (entry);
   3722 
   3723       gotidx = entry->gotidx;
   3724       BFD_ASSERT (gotidx > 0 && gotidx < htab->sgot->size);
   3725 
   3726       return entry;
   3727     }
   3728 
   3729   lookup.abfd = NULL;
   3730   lookup.symndx = -1;
   3731   lookup.d.address = value;
   3732   loc = htab_find_slot (g->got_entries, &lookup, INSERT);
   3733   if (!loc)
   3734     return NULL;
   3735 
   3736   entry = (struct mips_got_entry *) *loc;
   3737   if (entry)
   3738     return entry;
   3739 
   3740   if (g->assigned_low_gotno > g->assigned_high_gotno)
   3741     {
   3742       /* We didn't allocate enough space in the GOT.  */
   3743       (*_bfd_error_handler)
   3744 	(_("not enough GOT space for local GOT entries"));
   3745       bfd_set_error (bfd_error_bad_value);
   3746       return NULL;
   3747     }
   3748 
   3749   entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
   3750   if (!entry)
   3751     return NULL;
   3752 
   3753   if (got16_reloc_p (r_type)
   3754       || call16_reloc_p (r_type)
   3755       || got_page_reloc_p (r_type)
   3756       || got_disp_reloc_p (r_type))
   3757     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++;
   3758   else
   3759     lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--;
   3760 
   3761   *entry = lookup;
   3762   *loc = entry;
   3763 
   3764   MIPS_ELF_PUT_WORD (abfd, value, htab->sgot->contents + entry->gotidx);
   3765 
   3766   /* These GOT entries need a dynamic relocation on VxWorks.  */
   3767   if (htab->is_vxworks)
   3768     {
   3769       Elf_Internal_Rela outrel;
   3770       asection *s;
   3771       bfd_byte *rloc;
   3772       bfd_vma got_address;
   3773 
   3774       s = mips_elf_rel_dyn_section (info, FALSE);
   3775       got_address = (htab->sgot->output_section->vma
   3776 		     + htab->sgot->output_offset
   3777 		     + entry->gotidx);
   3778 
   3779       rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
   3780       outrel.r_offset = got_address;
   3781       outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
   3782       outrel.r_addend = value;
   3783       bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
   3784     }
   3785 
   3786   return entry;
   3787 }
   3788 
   3789 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
   3790    The number might be exact or a worst-case estimate, depending on how
   3791    much information is available to elf_backend_omit_section_dynsym at
   3792    the current linking stage.  */
   3793 
   3794 static bfd_size_type
   3795 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
   3796 {
   3797   bfd_size_type count;
   3798 
   3799   count = 0;
   3800   if (info->shared || elf_hash_table (info)->is_relocatable_executable)
   3801     {
   3802       asection *p;
   3803       const struct elf_backend_data *bed;
   3804 
   3805       bed = get_elf_backend_data (output_bfd);
   3806       for (p = output_bfd->sections; p ; p = p->next)
   3807 	if ((p->flags & SEC_EXCLUDE) == 0
   3808 	    && (p->flags & SEC_ALLOC) != 0
   3809 	    && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
   3810 	  ++count;
   3811     }
   3812   return count;
   3813 }
   3814 
   3815 /* Sort the dynamic symbol table so that symbols that need GOT entries
   3816    appear towards the end.  */
   3817 
   3818 static bfd_boolean
   3819 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
   3820 {
   3821   struct mips_elf_link_hash_table *htab;
   3822   struct mips_elf_hash_sort_data hsd;
   3823   struct mips_got_info *g;
   3824 
   3825   if (elf_hash_table (info)->dynsymcount == 0)
   3826     return TRUE;
   3827 
   3828   htab = mips_elf_hash_table (info);
   3829   BFD_ASSERT (htab != NULL);
   3830 
   3831   g = htab->got_info;
   3832   if (g == NULL)
   3833     return TRUE;
   3834 
   3835   hsd.low = NULL;
   3836   hsd.max_unref_got_dynindx
   3837     = hsd.min_got_dynindx
   3838     = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
   3839   hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
   3840   mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
   3841 				elf_hash_table (info)),
   3842 			       mips_elf_sort_hash_table_f,
   3843 			       &hsd);
   3844 
   3845   /* There should have been enough room in the symbol table to
   3846      accommodate both the GOT and non-GOT symbols.  */
   3847   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
   3848   BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
   3849 	      == elf_hash_table (info)->dynsymcount);
   3850   BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
   3851 	      == g->global_gotno);
   3852 
   3853   /* Now we know which dynamic symbol has the lowest dynamic symbol
   3854      table index in the GOT.  */
   3855   htab->global_gotsym = hsd.low;
   3856 
   3857   return TRUE;
   3858 }
   3859 
   3860 /* If H needs a GOT entry, assign it the highest available dynamic
   3861    index.  Otherwise, assign it the lowest available dynamic
   3862    index.  */
   3863 
   3864 static bfd_boolean
   3865 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
   3866 {
   3867   struct mips_elf_hash_sort_data *hsd = data;
   3868 
   3869   /* Symbols without dynamic symbol table entries aren't interesting
   3870      at all.  */
   3871   if (h->root.dynindx == -1)
   3872     return TRUE;
   3873 
   3874   switch (h->global_got_area)
   3875     {
   3876     case GGA_NONE:
   3877       h->root.dynindx = hsd->max_non_got_dynindx++;
   3878       break;
   3879 
   3880     case GGA_NORMAL:
   3881       h->root.dynindx = --hsd->min_got_dynindx;
   3882       hsd->low = (struct elf_link_hash_entry *) h;
   3883       break;
   3884 
   3885     case GGA_RELOC_ONLY:
   3886       if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
   3887 	hsd->low = (struct elf_link_hash_entry *) h;
   3888       h->root.dynindx = hsd->max_unref_got_dynindx++;
   3889       break;
   3890     }
   3891 
   3892   return TRUE;
   3893 }
   3894 
   3895 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
   3896    (which is owned by the caller and shouldn't be added to the
   3897    hash table directly).  */
   3898 
   3899 static bfd_boolean
   3900 mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd,
   3901 			   struct mips_got_entry *lookup)
   3902 {
   3903   struct mips_elf_link_hash_table *htab;
   3904   struct mips_got_entry *entry;
   3905   struct mips_got_info *g;
   3906   void **loc, **bfd_loc;
   3907 
   3908   /* Make sure there's a slot for this entry in the master GOT.  */
   3909   htab = mips_elf_hash_table (info);
   3910   g = htab->got_info;
   3911   loc = htab_find_slot (g->got_entries, lookup, INSERT);
   3912   if (!loc)
   3913     return FALSE;
   3914 
   3915   /* Populate the entry if it isn't already.  */
   3916   entry = (struct mips_got_entry *) *loc;
   3917   if (!entry)
   3918     {
   3919       entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
   3920       if (!entry)
   3921 	return FALSE;
   3922 
   3923       lookup->tls_initialized = FALSE;
   3924       lookup->gotidx = -1;
   3925       *entry = *lookup;
   3926       *loc = entry;
   3927     }
   3928 
   3929   /* Reuse the same GOT entry for the BFD's GOT.  */
   3930   g = mips_elf_bfd_got (abfd, TRUE);
   3931   if (!g)
   3932     return FALSE;
   3933 
   3934   bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT);
   3935   if (!bfd_loc)
   3936     return FALSE;
   3937 
   3938   if (!*bfd_loc)
   3939     *bfd_loc = entry;
   3940   return TRUE;
   3941 }
   3942 
   3943 /* ABFD has a GOT relocation of type R_TYPE against H.  Reserve a GOT
   3944    entry for it.  FOR_CALL is true if the caller is only interested in
   3945    using the GOT entry for calls.  */
   3946 
   3947 static bfd_boolean
   3948 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
   3949 				   bfd *abfd, struct bfd_link_info *info,
   3950 				   bfd_boolean for_call, int r_type)
   3951 {
   3952   struct mips_elf_link_hash_table *htab;
   3953   struct mips_elf_link_hash_entry *hmips;
   3954   struct mips_got_entry entry;
   3955   unsigned char tls_type;
   3956 
   3957   htab = mips_elf_hash_table (info);
   3958   BFD_ASSERT (htab != NULL);
   3959 
   3960   hmips = (struct mips_elf_link_hash_entry *) h;
   3961   if (!for_call)
   3962     hmips->got_only_for_calls = FALSE;
   3963 
   3964   /* A global symbol in the GOT must also be in the dynamic symbol
   3965      table.  */
   3966   if (h->dynindx == -1)
   3967     {
   3968       switch (ELF_ST_VISIBILITY (h->other))
   3969 	{
   3970 	case STV_INTERNAL:
   3971 	case STV_HIDDEN:
   3972 	  _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
   3973 	  break;
   3974 	}
   3975       if (!bfd_elf_link_record_dynamic_symbol (info, h))
   3976 	return FALSE;
   3977     }
   3978 
   3979   tls_type = mips_elf_reloc_tls_type (r_type);
   3980   if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL)
   3981     hmips->global_got_area = GGA_NORMAL;
   3982 
   3983   entry.abfd = abfd;
   3984   entry.symndx = -1;
   3985   entry.d.h = (struct mips_elf_link_hash_entry *) h;
   3986   entry.tls_type = tls_type;
   3987   return mips_elf_record_got_entry (info, abfd, &entry);
   3988 }
   3989 
   3990 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
   3991    where SYMNDX is a local symbol.  Reserve a GOT entry for it.  */
   3992 
   3993 static bfd_boolean
   3994 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
   3995 				  struct bfd_link_info *info, int r_type)
   3996 {
   3997   struct mips_elf_link_hash_table *htab;
   3998   struct mips_got_info *g;
   3999   struct mips_got_entry entry;
   4000 
   4001   htab = mips_elf_hash_table (info);
   4002   BFD_ASSERT (htab != NULL);
   4003 
   4004   g = htab->got_info;
   4005   BFD_ASSERT (g != NULL);
   4006 
   4007   entry.abfd = abfd;
   4008   entry.symndx = symndx;
   4009   entry.d.addend = addend;
   4010   entry.tls_type = mips_elf_reloc_tls_type (r_type);
   4011   return mips_elf_record_got_entry (info, abfd, &entry);
   4012 }
   4013 
   4014 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
   4015    H is the symbol's hash table entry, or null if SYMNDX is local
   4016    to ABFD.  */
   4017 
   4018 static bfd_boolean
   4019 mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd,
   4020 			      long symndx, struct elf_link_hash_entry *h,
   4021 			      bfd_signed_vma addend)
   4022 {
   4023   struct mips_elf_link_hash_table *htab;
   4024   struct mips_got_info *g1, *g2;
   4025   struct mips_got_page_ref lookup, *entry;
   4026   void **loc, **bfd_loc;
   4027 
   4028   htab = mips_elf_hash_table (info);
   4029   BFD_ASSERT (htab != NULL);
   4030 
   4031   g1 = htab->got_info;
   4032   BFD_ASSERT (g1 != NULL);
   4033 
   4034   if (h)
   4035     {
   4036       lookup.symndx = -1;
   4037       lookup.u.h = (struct mips_elf_link_hash_entry *) h;
   4038     }
   4039   else
   4040     {
   4041       lookup.symndx = symndx;
   4042       lookup.u.abfd = abfd;
   4043     }
   4044   lookup.addend = addend;
   4045   loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT);
   4046   if (loc == NULL)
   4047     return FALSE;
   4048 
   4049   entry = (struct mips_got_page_ref *) *loc;
   4050   if (!entry)
   4051     {
   4052       entry = bfd_alloc (abfd, sizeof (*entry));
   4053       if (!entry)
   4054 	return FALSE;
   4055 
   4056       *entry = lookup;
   4057       *loc = entry;
   4058     }
   4059 
   4060   /* Add the same entry to the BFD's GOT.  */
   4061   g2 = mips_elf_bfd_got (abfd, TRUE);
   4062   if (!g2)
   4063     return FALSE;
   4064 
   4065   bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT);
   4066   if (!bfd_loc)
   4067     return FALSE;
   4068 
   4069   if (!*bfd_loc)
   4070     *bfd_loc = entry;
   4071 
   4072   return TRUE;
   4073 }
   4074 
   4075 /* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
   4076 
   4077 static void
   4078 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
   4079 				       unsigned int n)
   4080 {
   4081   asection *s;
   4082   struct mips_elf_link_hash_table *htab;
   4083 
   4084   htab = mips_elf_hash_table (info);
   4085   BFD_ASSERT (htab != NULL);
   4086 
   4087   s = mips_elf_rel_dyn_section (info, FALSE);
   4088   BFD_ASSERT (s != NULL);
   4089 
   4090   if (htab->is_vxworks)
   4091     s->size += n * MIPS_ELF_RELA_SIZE (abfd);
   4092   else
   4093     {
   4094       if (s->size == 0)
   4095 	{
   4096 	  /* Make room for a null element.  */
   4097 	  s->size += MIPS_ELF_REL_SIZE (abfd);
   4098 	  ++s->reloc_count;
   4099 	}
   4100       s->size += n * MIPS_ELF_REL_SIZE (abfd);
   4101     }
   4102 }
   4103 
   4104 /* A htab_traverse callback for GOT entries, with DATA pointing to a
   4106    mips_elf_traverse_got_arg structure.  Count the number of GOT
   4107    entries and TLS relocs.  Set DATA->value to true if we need
   4108    to resolve indirect or warning symbols and then recreate the GOT.  */
   4109 
   4110 static int
   4111 mips_elf_check_recreate_got (void **entryp, void *data)
   4112 {
   4113   struct mips_got_entry *entry;
   4114   struct mips_elf_traverse_got_arg *arg;
   4115 
   4116   entry = (struct mips_got_entry *) *entryp;
   4117   arg = (struct mips_elf_traverse_got_arg *) data;
   4118   if (entry->abfd != NULL && entry->symndx == -1)
   4119     {
   4120       struct mips_elf_link_hash_entry *h;
   4121 
   4122       h = entry->d.h;
   4123       if (h->root.root.type == bfd_link_hash_indirect
   4124 	  || h->root.root.type == bfd_link_hash_warning)
   4125 	{
   4126 	  arg->value = TRUE;
   4127 	  return 0;
   4128 	}
   4129     }
   4130   mips_elf_count_got_entry (arg->info, arg->g, entry);
   4131   return 1;
   4132 }
   4133 
   4134 /* A htab_traverse callback for GOT entries, with DATA pointing to a
   4135    mips_elf_traverse_got_arg structure.  Add all entries to DATA->g,
   4136    converting entries for indirect and warning symbols into entries
   4137    for the target symbol.  Set DATA->g to null on error.  */
   4138 
   4139 static int
   4140 mips_elf_recreate_got (void **entryp, void *data)
   4141 {
   4142   struct mips_got_entry new_entry, *entry;
   4143   struct mips_elf_traverse_got_arg *arg;
   4144   void **slot;
   4145 
   4146   entry = (struct mips_got_entry *) *entryp;
   4147   arg = (struct mips_elf_traverse_got_arg *) data;
   4148   if (entry->abfd != NULL
   4149       && entry->symndx == -1
   4150       && (entry->d.h->root.root.type == bfd_link_hash_indirect
   4151 	  || entry->d.h->root.root.type == bfd_link_hash_warning))
   4152     {
   4153       struct mips_elf_link_hash_entry *h;
   4154 
   4155       new_entry = *entry;
   4156       entry = &new_entry;
   4157       h = entry->d.h;
   4158       do
   4159 	{
   4160 	  BFD_ASSERT (h->global_got_area == GGA_NONE);
   4161 	  h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
   4162 	}
   4163       while (h->root.root.type == bfd_link_hash_indirect
   4164 	     || h->root.root.type == bfd_link_hash_warning);
   4165       entry->d.h = h;
   4166     }
   4167   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
   4168   if (slot == NULL)
   4169     {
   4170       arg->g = NULL;
   4171       return 0;
   4172     }
   4173   if (*slot == NULL)
   4174     {
   4175       if (entry == &new_entry)
   4176 	{
   4177 	  entry = bfd_alloc (entry->abfd, sizeof (*entry));
   4178 	  if (!entry)
   4179 	    {
   4180 	      arg->g = NULL;
   4181 	      return 0;
   4182 	    }
   4183 	  *entry = new_entry;
   4184 	}
   4185       *slot = entry;
   4186       mips_elf_count_got_entry (arg->info, arg->g, entry);
   4187     }
   4188   return 1;
   4189 }
   4190 
   4191 /* Return the maximum number of GOT page entries required for RANGE.  */
   4192 
   4193 static bfd_vma
   4194 mips_elf_pages_for_range (const struct mips_got_page_range *range)
   4195 {
   4196   return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
   4197 }
   4198 
   4199 /* Record that G requires a page entry that can reach SEC + ADDEND.  */
   4200 
   4201 static bfd_boolean
   4202 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg,
   4203 				asection *sec, bfd_signed_vma addend)
   4204 {
   4205   struct mips_got_info *g = arg->g;
   4206   struct mips_got_page_entry lookup, *entry;
   4207   struct mips_got_page_range **range_ptr, *range;
   4208   bfd_vma old_pages, new_pages;
   4209   void **loc;
   4210 
   4211   /* Find the mips_got_page_entry hash table entry for this section.  */
   4212   lookup.sec = sec;
   4213   loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
   4214   if (loc == NULL)
   4215     return FALSE;
   4216 
   4217   /* Create a mips_got_page_entry if this is the first time we've
   4218      seen the section.  */
   4219   entry = (struct mips_got_page_entry *) *loc;
   4220   if (!entry)
   4221     {
   4222       entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry));
   4223       if (!entry)
   4224 	return FALSE;
   4225 
   4226       entry->sec = sec;
   4227       *loc = entry;
   4228     }
   4229 
   4230   /* Skip over ranges whose maximum extent cannot share a page entry
   4231      with ADDEND.  */
   4232   range_ptr = &entry->ranges;
   4233   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
   4234     range_ptr = &(*range_ptr)->next;
   4235 
   4236   /* If we scanned to the end of the list, or found a range whose
   4237      minimum extent cannot share a page entry with ADDEND, create
   4238      a new singleton range.  */
   4239   range = *range_ptr;
   4240   if (!range || addend < range->min_addend - 0xffff)
   4241     {
   4242       range = bfd_zalloc (arg->info->output_bfd, sizeof (*range));
   4243       if (!range)
   4244 	return FALSE;
   4245 
   4246       range->next = *range_ptr;
   4247       range->min_addend = addend;
   4248       range->max_addend = addend;
   4249 
   4250       *range_ptr = range;
   4251       entry->num_pages++;
   4252       g->page_gotno++;
   4253       return TRUE;
   4254     }
   4255 
   4256   /* Remember how many pages the old range contributed.  */
   4257   old_pages = mips_elf_pages_for_range (range);
   4258 
   4259   /* Update the ranges.  */
   4260   if (addend < range->min_addend)
   4261     range->min_addend = addend;
   4262   else if (addend > range->max_addend)
   4263     {
   4264       if (range->next && addend >= range->next->min_addend - 0xffff)
   4265 	{
   4266 	  old_pages += mips_elf_pages_for_range (range->next);
   4267 	  range->max_addend = range->next->max_addend;
   4268 	  range->next = range->next->next;
   4269 	}
   4270       else
   4271 	range->max_addend = addend;
   4272     }
   4273 
   4274   /* Record any change in the total estimate.  */
   4275   new_pages = mips_elf_pages_for_range (range);
   4276   if (old_pages != new_pages)
   4277     {
   4278       entry->num_pages += new_pages - old_pages;
   4279       g->page_gotno += new_pages - old_pages;
   4280     }
   4281 
   4282   return TRUE;
   4283 }
   4284 
   4285 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
   4286    and for which DATA points to a mips_elf_traverse_got_arg.  Work out
   4287    whether the page reference described by *REFP needs a GOT page entry,
   4288    and record that entry in DATA->g if so.  Set DATA->g to null on failure.  */
   4289 
   4290 static bfd_boolean
   4291 mips_elf_resolve_got_page_ref (void **refp, void *data)
   4292 {
   4293   struct mips_got_page_ref *ref;
   4294   struct mips_elf_traverse_got_arg *arg;
   4295   struct mips_elf_link_hash_table *htab;
   4296   asection *sec;
   4297   bfd_vma addend;
   4298 
   4299   ref = (struct mips_got_page_ref *) *refp;
   4300   arg = (struct mips_elf_traverse_got_arg *) data;
   4301   htab = mips_elf_hash_table (arg->info);
   4302 
   4303   if (ref->symndx < 0)
   4304     {
   4305       struct mips_elf_link_hash_entry *h;
   4306 
   4307       /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries.  */
   4308       h = ref->u.h;
   4309       if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root))
   4310 	return 1;
   4311 
   4312       /* Ignore undefined symbols; we'll issue an error later if
   4313 	 appropriate.  */
   4314       if (!((h->root.root.type == bfd_link_hash_defined
   4315 	     || h->root.root.type == bfd_link_hash_defweak)
   4316 	    && h->root.root.u.def.section))
   4317 	return 1;
   4318 
   4319       sec = h->root.root.u.def.section;
   4320       addend = h->root.root.u.def.value + ref->addend;
   4321     }
   4322   else
   4323     {
   4324       Elf_Internal_Sym *isym;
   4325 
   4326       /* Read in the symbol.  */
   4327       isym = bfd_sym_from_r_symndx (&htab->sym_cache, ref->u.abfd,
   4328 				    ref->symndx);
   4329       if (isym == NULL)
   4330 	{
   4331 	  arg->g = NULL;
   4332 	  return 0;
   4333 	}
   4334 
   4335       /* Get the associated input section.  */
   4336       sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx);
   4337       if (sec == NULL)
   4338 	{
   4339 	  arg->g = NULL;
   4340 	  return 0;
   4341 	}
   4342 
   4343       /* If this is a mergable section, work out the section and offset
   4344 	 of the merged data.  For section symbols, the addend specifies
   4345 	 of the offset _of_ the first byte in the data, otherwise it
   4346 	 specifies the offset _from_ the first byte.  */
   4347       if (sec->flags & SEC_MERGE)
   4348 	{
   4349 	  void *secinfo;
   4350 
   4351 	  secinfo = elf_section_data (sec)->sec_info;
   4352 	  if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
   4353 	    addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
   4354 						 isym->st_value + ref->addend);
   4355 	  else
   4356 	    addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
   4357 						 isym->st_value) + ref->addend;
   4358 	}
   4359       else
   4360 	addend = isym->st_value + ref->addend;
   4361     }
   4362   if (!mips_elf_record_got_page_entry (arg, sec, addend))
   4363     {
   4364       arg->g = NULL;
   4365       return 0;
   4366     }
   4367   return 1;
   4368 }
   4369 
   4370 /* If any entries in G->got_entries are for indirect or warning symbols,
   4371    replace them with entries for the target symbol.  Convert g->got_page_refs
   4372    into got_page_entry structures and estimate the number of page entries
   4373    that they require.  */
   4374 
   4375 static bfd_boolean
   4376 mips_elf_resolve_final_got_entries (struct bfd_link_info *info,
   4377 				    struct mips_got_info *g)
   4378 {
   4379   struct mips_elf_traverse_got_arg tga;
   4380   struct mips_got_info oldg;
   4381 
   4382   oldg = *g;
   4383 
   4384   tga.info = info;
   4385   tga.g = g;
   4386   tga.value = FALSE;
   4387   htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga);
   4388   if (tga.value)
   4389     {
   4390       *g = oldg;
   4391       g->got_entries = htab_create (htab_size (oldg.got_entries),
   4392 				    mips_elf_got_entry_hash,
   4393 				    mips_elf_got_entry_eq, NULL);
   4394       if (!g->got_entries)
   4395 	return FALSE;
   4396 
   4397       htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga);
   4398       if (!tga.g)
   4399 	return FALSE;
   4400 
   4401       htab_delete (oldg.got_entries);
   4402     }
   4403 
   4404   g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
   4405 					 mips_got_page_entry_eq, NULL);
   4406   if (g->got_page_entries == NULL)
   4407     return FALSE;
   4408 
   4409   tga.info = info;
   4410   tga.g = g;
   4411   htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga);
   4412 
   4413   return TRUE;
   4414 }
   4415 
   4416 /* Return true if a GOT entry for H should live in the local rather than
   4417    global GOT area.  */
   4418 
   4419 static bfd_boolean
   4420 mips_use_local_got_p (struct bfd_link_info *info,
   4421 		      struct mips_elf_link_hash_entry *h)
   4422 {
   4423   /* Symbols that aren't in the dynamic symbol table must live in the
   4424      local GOT.  This includes symbols that are completely undefined
   4425      and which therefore don't bind locally.  We'll report undefined
   4426      symbols later if appropriate.  */
   4427   if (h->root.dynindx == -1)
   4428     return TRUE;
   4429 
   4430   /* Symbols that bind locally can (and in the case of forced-local
   4431      symbols, must) live in the local GOT.  */
   4432   if (h->got_only_for_calls
   4433       ? SYMBOL_CALLS_LOCAL (info, &h->root)
   4434       : SYMBOL_REFERENCES_LOCAL (info, &h->root))
   4435     return TRUE;
   4436 
   4437   /* If this is an executable that must provide a definition of the symbol,
   4438      either though PLTs or copy relocations, then that address should go in
   4439      the local rather than global GOT.  */
   4440   if (info->executable && h->has_static_relocs)
   4441     return TRUE;
   4442 
   4443   return FALSE;
   4444 }
   4445 
   4446 /* A mips_elf_link_hash_traverse callback for which DATA points to the
   4447    link_info structure.  Decide whether the hash entry needs an entry in
   4448    the global part of the primary GOT, setting global_got_area accordingly.
   4449    Count the number of global symbols that are in the primary GOT only
   4450    because they have relocations against them (reloc_only_gotno).  */
   4451 
   4452 static int
   4453 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
   4454 {
   4455   struct bfd_link_info *info;
   4456   struct mips_elf_link_hash_table *htab;
   4457   struct mips_got_info *g;
   4458 
   4459   info = (struct bfd_link_info *) data;
   4460   htab = mips_elf_hash_table (info);
   4461   g = htab->got_info;
   4462   if (h->global_got_area != GGA_NONE)
   4463     {
   4464       /* Make a final decision about whether the symbol belongs in the
   4465 	 local or global GOT.  */
   4466       if (mips_use_local_got_p (info, h))
   4467 	/* The symbol belongs in the local GOT.  We no longer need this
   4468 	   entry if it was only used for relocations; those relocations
   4469 	   will be against the null or section symbol instead of H.  */
   4470 	h->global_got_area = GGA_NONE;
   4471       else if (htab->is_vxworks
   4472 	       && h->got_only_for_calls
   4473 	       && h->root.plt.plist->mips_offset != MINUS_ONE)
   4474 	/* On VxWorks, calls can refer directly to the .got.plt entry;
   4475 	   they don't need entries in the regular GOT.  .got.plt entries
   4476 	   will be allocated by _bfd_mips_elf_adjust_dynamic_symbol.  */
   4477 	h->global_got_area = GGA_NONE;
   4478       else if (h->global_got_area == GGA_RELOC_ONLY)
   4479 	{
   4480 	  g->reloc_only_gotno++;
   4481 	  g->global_gotno++;
   4482 	}
   4483     }
   4484   return 1;
   4485 }
   4486 
   4487 /* A htab_traverse callback for GOT entries.  Add each one to the GOT
   4489    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
   4490 
   4491 static int
   4492 mips_elf_add_got_entry (void **entryp, void *data)
   4493 {
   4494   struct mips_got_entry *entry;
   4495   struct mips_elf_traverse_got_arg *arg;
   4496   void **slot;
   4497 
   4498   entry = (struct mips_got_entry *) *entryp;
   4499   arg = (struct mips_elf_traverse_got_arg *) data;
   4500   slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
   4501   if (!slot)
   4502     {
   4503       arg->g = NULL;
   4504       return 0;
   4505     }
   4506   if (!*slot)
   4507     {
   4508       *slot = entry;
   4509       mips_elf_count_got_entry (arg->info, arg->g, entry);
   4510     }
   4511   return 1;
   4512 }
   4513 
   4514 /* A htab_traverse callback for GOT page entries.  Add each one to the GOT
   4515    given in mips_elf_traverse_got_arg DATA.  Clear DATA->G on error.  */
   4516 
   4517 static int
   4518 mips_elf_add_got_page_entry (void **entryp, void *data)
   4519 {
   4520   struct mips_got_page_entry *entry;
   4521   struct mips_elf_traverse_got_arg *arg;
   4522   void **slot;
   4523 
   4524   entry = (struct mips_got_page_entry *) *entryp;
   4525   arg = (struct mips_elf_traverse_got_arg *) data;
   4526   slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT);
   4527   if (!slot)
   4528     {
   4529       arg->g = NULL;
   4530       return 0;
   4531     }
   4532   if (!*slot)
   4533     {
   4534       *slot = entry;
   4535       arg->g->page_gotno += entry->num_pages;
   4536     }
   4537   return 1;
   4538 }
   4539 
   4540 /* Consider merging FROM, which is ABFD's GOT, into TO.  Return -1 if
   4541    this would lead to overflow, 1 if they were merged successfully,
   4542    and 0 if a merge failed due to lack of memory.  (These values are chosen
   4543    so that nonnegative return values can be returned by a htab_traverse
   4544    callback.)  */
   4545 
   4546 static int
   4547 mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from,
   4548 			 struct mips_got_info *to,
   4549 			 struct mips_elf_got_per_bfd_arg *arg)
   4550 {
   4551   struct mips_elf_traverse_got_arg tga;
   4552   unsigned int estimate;
   4553 
   4554   /* Work out how many page entries we would need for the combined GOT.  */
   4555   estimate = arg->max_pages;
   4556   if (estimate >= from->page_gotno + to->page_gotno)
   4557     estimate = from->page_gotno + to->page_gotno;
   4558 
   4559   /* And conservatively estimate how many local and TLS entries
   4560      would be needed.  */
   4561   estimate += from->local_gotno + to->local_gotno;
   4562   estimate += from->tls_gotno + to->tls_gotno;
   4563 
   4564   /* If we're merging with the primary got, any TLS relocations will
   4565      come after the full set of global entries.  Otherwise estimate those
   4566      conservatively as well.  */
   4567   if (to == arg->primary && from->tls_gotno + to->tls_gotno)
   4568     estimate += arg->global_count;
   4569   else
   4570     estimate += from->global_gotno + to->global_gotno;
   4571 
   4572   /* Bail out if the combined GOT might be too big.  */
   4573   if (estimate > arg->max_count)
   4574     return -1;
   4575 
   4576   /* Transfer the bfd's got information from FROM to TO.  */
   4577   tga.info = arg->info;
   4578   tga.g = to;
   4579   htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga);
   4580   if (!tga.g)
   4581     return 0;
   4582 
   4583   htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga);
   4584   if (!tga.g)
   4585     return 0;
   4586 
   4587   mips_elf_replace_bfd_got (abfd, to);
   4588   return 1;
   4589 }
   4590 
   4591 /* Attempt to merge GOT G, which belongs to ABFD.  Try to use as much
   4592    as possible of the primary got, since it doesn't require explicit
   4593    dynamic relocations, but don't use bfds that would reference global
   4594    symbols out of the addressable range.  Failing the primary got,
   4595    attempt to merge with the current got, or finish the current got
   4596    and then make make the new got current.  */
   4597 
   4598 static bfd_boolean
   4599 mips_elf_merge_got (bfd *abfd, struct mips_got_info *g,
   4600 		    struct mips_elf_got_per_bfd_arg *arg)
   4601 {
   4602   unsigned int estimate;
   4603   int result;
   4604 
   4605   if (!mips_elf_resolve_final_got_entries (arg->info, g))
   4606     return FALSE;
   4607 
   4608   /* Work out the number of page, local and TLS entries.  */
   4609   estimate = arg->max_pages;
   4610   if (estimate > g->page_gotno)
   4611     estimate = g->page_gotno;
   4612   estimate += g->local_gotno + g->tls_gotno;
   4613 
   4614   /* We place TLS GOT entries after both locals and globals.  The globals
   4615      for the primary GOT may overflow the normal GOT size limit, so be
   4616      sure not to merge a GOT which requires TLS with the primary GOT in that
   4617      case.  This doesn't affect non-primary GOTs.  */
   4618   estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
   4619 
   4620   if (estimate <= arg->max_count)
   4621     {
   4622       /* If we don't have a primary GOT, use it as
   4623 	 a starting point for the primary GOT.  */
   4624       if (!arg->primary)
   4625 	{
   4626 	  arg->primary = g;
   4627 	  return TRUE;
   4628 	}
   4629 
   4630       /* Try merging with the primary GOT.  */
   4631       result = mips_elf_merge_got_with (abfd, g, arg->primary, arg);
   4632       if (result >= 0)
   4633 	return result;
   4634     }
   4635 
   4636   /* If we can merge with the last-created got, do it.  */
   4637   if (arg->current)
   4638     {
   4639       result = mips_elf_merge_got_with (abfd, g, arg->current, arg);
   4640       if (result >= 0)
   4641 	return result;
   4642     }
   4643 
   4644   /* Well, we couldn't merge, so create a new GOT.  Don't check if it
   4645      fits; if it turns out that it doesn't, we'll get relocation
   4646      overflows anyway.  */
   4647   g->next = arg->current;
   4648   arg->current = g;
   4649 
   4650   return TRUE;
   4651 }
   4652 
   4653 /* ENTRYP is a hash table entry for a mips_got_entry.  Set its gotidx
   4654    to GOTIDX, duplicating the entry if it has already been assigned
   4655    an index in a different GOT.  */
   4656 
   4657 static bfd_boolean
   4658 mips_elf_set_gotidx (void **entryp, long gotidx)
   4659 {
   4660   struct mips_got_entry *entry;
   4661 
   4662   entry = (struct mips_got_entry *) *entryp;
   4663   if (entry->gotidx > 0)
   4664     {
   4665       struct mips_got_entry *new_entry;
   4666 
   4667       new_entry = bfd_alloc (entry->abfd, sizeof (*entry));
   4668       if (!new_entry)
   4669 	return FALSE;
   4670 
   4671       *new_entry = *entry;
   4672       *entryp = new_entry;
   4673       entry = new_entry;
   4674     }
   4675   entry->gotidx = gotidx;
   4676   return TRUE;
   4677 }
   4678 
   4679 /* Set the TLS GOT index for the GOT entry in ENTRYP.  DATA points to a
   4680    mips_elf_traverse_got_arg in which DATA->value is the size of one
   4681    GOT entry.  Set DATA->g to null on failure.  */
   4682 
   4683 static int
   4684 mips_elf_initialize_tls_index (void **entryp, void *data)
   4685 {
   4686   struct mips_got_entry *entry;
   4687   struct mips_elf_traverse_got_arg *arg;
   4688 
   4689   /* We're only interested in TLS symbols.  */
   4690   entry = (struct mips_got_entry *) *entryp;
   4691   if (entry->tls_type == GOT_TLS_NONE)
   4692     return 1;
   4693 
   4694   arg = (struct mips_elf_traverse_got_arg *) data;
   4695   if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno))
   4696     {
   4697       arg->g = NULL;
   4698       return 0;
   4699     }
   4700 
   4701   /* Account for the entries we've just allocated.  */
   4702   arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type);
   4703   return 1;
   4704 }
   4705 
   4706 /* A htab_traverse callback for GOT entries, where DATA points to a
   4707    mips_elf_traverse_got_arg.  Set the global_got_area of each global
   4708    symbol to DATA->value.  */
   4709 
   4710 static int
   4711 mips_elf_set_global_got_area (void **entryp, void *data)
   4712 {
   4713   struct mips_got_entry *entry;
   4714   struct mips_elf_traverse_got_arg *arg;
   4715 
   4716   entry = (struct mips_got_entry *) *entryp;
   4717   arg = (struct mips_elf_traverse_got_arg *) data;
   4718   if (entry->abfd != NULL
   4719       && entry->symndx == -1
   4720       && entry->d.h->global_got_area != GGA_NONE)
   4721     entry->d.h->global_got_area = arg->value;
   4722   return 1;
   4723 }
   4724 
   4725 /* A htab_traverse callback for secondary GOT entries, where DATA points
   4726    to a mips_elf_traverse_got_arg.  Assign GOT indices to global entries
   4727    and record the number of relocations they require.  DATA->value is
   4728    the size of one GOT entry.  Set DATA->g to null on failure.  */
   4729 
   4730 static int
   4731 mips_elf_set_global_gotidx (void **entryp, void *data)
   4732 {
   4733   struct mips_got_entry *entry;
   4734   struct mips_elf_traverse_got_arg *arg;
   4735 
   4736   entry = (struct mips_got_entry *) *entryp;
   4737   arg = (struct mips_elf_traverse_got_arg *) data;
   4738   if (entry->abfd != NULL
   4739       && entry->symndx == -1
   4740       && entry->d.h->global_got_area != GGA_NONE)
   4741     {
   4742       if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno))
   4743 	{
   4744 	  arg->g = NULL;
   4745 	  return 0;
   4746 	}
   4747       arg->g->assigned_low_gotno += 1;
   4748 
   4749       if (arg->info->shared
   4750 	  || (elf_hash_table (arg->info)->dynamic_sections_created
   4751 	      && entry->d.h->root.def_dynamic
   4752 	      && !entry->d.h->root.def_regular))
   4753 	arg->g->relocs += 1;
   4754     }
   4755 
   4756   return 1;
   4757 }
   4758 
   4759 /* A htab_traverse callback for GOT entries for which DATA is the
   4760    bfd_link_info.  Forbid any global symbols from having traditional
   4761    lazy-binding stubs.  */
   4762 
   4763 static int
   4764 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
   4765 {
   4766   struct bfd_link_info *info;
   4767   struct mips_elf_link_hash_table *htab;
   4768   struct mips_got_entry *entry;
   4769 
   4770   entry = (struct mips_got_entry *) *entryp;
   4771   info = (struct bfd_link_info *) data;
   4772   htab = mips_elf_hash_table (info);
   4773   BFD_ASSERT (htab != NULL);
   4774 
   4775   if (entry->abfd != NULL
   4776       && entry->symndx == -1
   4777       && entry->d.h->needs_lazy_stub)
   4778     {
   4779       entry->d.h->needs_lazy_stub = FALSE;
   4780       htab->lazy_stub_count--;
   4781     }
   4782 
   4783   return 1;
   4784 }
   4785 
   4786 /* Return the offset of an input bfd IBFD's GOT from the beginning of
   4787    the primary GOT.  */
   4788 static bfd_vma
   4789 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
   4790 {
   4791   if (!g->next)
   4792     return 0;
   4793 
   4794   g = mips_elf_bfd_got (ibfd, FALSE);
   4795   if (! g)
   4796     return 0;
   4797 
   4798   BFD_ASSERT (g->next);
   4799 
   4800   g = g->next;
   4801 
   4802   return (g->local_gotno + g->global_gotno + g->tls_gotno)
   4803     * MIPS_ELF_GOT_SIZE (abfd);
   4804 }
   4805 
   4806 /* Turn a single GOT that is too big for 16-bit addressing into
   4807    a sequence of GOTs, each one 16-bit addressable.  */
   4808 
   4809 static bfd_boolean
   4810 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
   4811 		    asection *got, bfd_size_type pages)
   4812 {
   4813   struct mips_elf_link_hash_table *htab;
   4814   struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
   4815   struct mips_elf_traverse_got_arg tga;
   4816   struct mips_got_info *g, *gg;
   4817   unsigned int assign, needed_relocs;
   4818   bfd *dynobj, *ibfd;
   4819 
   4820   dynobj = elf_hash_table (info)->dynobj;
   4821   htab = mips_elf_hash_table (info);
   4822   BFD_ASSERT (htab != NULL);
   4823 
   4824   g = htab->got_info;
   4825 
   4826   got_per_bfd_arg.obfd = abfd;
   4827   got_per_bfd_arg.info = info;
   4828   got_per_bfd_arg.current = NULL;
   4829   got_per_bfd_arg.primary = NULL;
   4830   got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
   4831 				/ MIPS_ELF_GOT_SIZE (abfd))
   4832 			       - htab->reserved_gotno);
   4833   got_per_bfd_arg.max_pages = pages;
   4834   /* The number of globals that will be included in the primary GOT.
   4835      See the calls to mips_elf_set_global_got_area below for more
   4836      information.  */
   4837   got_per_bfd_arg.global_count = g->global_gotno;
   4838 
   4839   /* Try to merge the GOTs of input bfds together, as long as they
   4840      don't seem to exceed the maximum GOT size, choosing one of them
   4841      to be the primary GOT.  */
   4842   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
   4843     {
   4844       gg = mips_elf_bfd_got (ibfd, FALSE);
   4845       if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg))
   4846 	return FALSE;
   4847     }
   4848 
   4849   /* If we do not find any suitable primary GOT, create an empty one.  */
   4850   if (got_per_bfd_arg.primary == NULL)
   4851     g->next = mips_elf_create_got_info (abfd);
   4852   else
   4853     g->next = got_per_bfd_arg.primary;
   4854   g->next->next = got_per_bfd_arg.current;
   4855 
   4856   /* GG is now the master GOT, and G is the primary GOT.  */
   4857   gg = g;
   4858   g = g->next;
   4859 
   4860   /* Map the output bfd to the primary got.  That's what we're going
   4861      to use for bfds that use GOT16 or GOT_PAGE relocations that we
   4862      didn't mark in check_relocs, and we want a quick way to find it.
   4863      We can't just use gg->next because we're going to reverse the
   4864      list.  */
   4865   mips_elf_replace_bfd_got (abfd, g);
   4866 
   4867   /* Every symbol that is referenced in a dynamic relocation must be
   4868      present in the primary GOT, so arrange for them to appear after
   4869      those that are actually referenced.  */
   4870   gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
   4871   g->global_gotno = gg->global_gotno;
   4872 
   4873   tga.info = info;
   4874   tga.value = GGA_RELOC_ONLY;
   4875   htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
   4876   tga.value = GGA_NORMAL;
   4877   htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
   4878 
   4879   /* Now go through the GOTs assigning them offset ranges.
   4880      [assigned_low_gotno, local_gotno[ will be set to the range of local
   4881      entries in each GOT.  We can then compute the end of a GOT by
   4882      adding local_gotno to global_gotno.  We reverse the list and make
   4883      it circular since then we'll be able to quickly compute the
   4884      beginning of a GOT, by computing the end of its predecessor.  To
   4885      avoid special cases for the primary GOT, while still preserving
   4886      assertions that are valid for both single- and multi-got links,
   4887      we arrange for the main got struct to have the right number of
   4888      global entries, but set its local_gotno such that the initial
   4889      offset of the primary GOT is zero.  Remember that the primary GOT
   4890      will become the last item in the circular linked list, so it
   4891      points back to the master GOT.  */
   4892   gg->local_gotno = -g->global_gotno;
   4893   gg->global_gotno = g->global_gotno;
   4894   gg->tls_gotno = 0;
   4895   assign = 0;
   4896   gg->next = gg;
   4897 
   4898   do
   4899     {
   4900       struct mips_got_info *gn;
   4901 
   4902       assign += htab->reserved_gotno;
   4903       g->assigned_low_gotno = assign;
   4904       g->local_gotno += assign;
   4905       g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
   4906       g->assigned_high_gotno = g->local_gotno - 1;
   4907       assign = g->local_gotno + g->global_gotno + g->tls_gotno;
   4908 
   4909       /* Take g out of the direct list, and push it onto the reversed
   4910 	 list that gg points to.  g->next is guaranteed to be nonnull after
   4911 	 this operation, as required by mips_elf_initialize_tls_index. */
   4912       gn = g->next;
   4913       g->next = gg->next;
   4914       gg->next = g;
   4915 
   4916       /* Set up any TLS entries.  We always place the TLS entries after
   4917 	 all non-TLS entries.  */
   4918       g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
   4919       tga.g = g;
   4920       tga.value = MIPS_ELF_GOT_SIZE (abfd);
   4921       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
   4922       if (!tga.g)
   4923 	return FALSE;
   4924       BFD_ASSERT (g->tls_assigned_gotno == assign);
   4925 
   4926       /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
   4927       g = gn;
   4928 
   4929       /* Forbid global symbols in every non-primary GOT from having
   4930 	 lazy-binding stubs.  */
   4931       if (g)
   4932 	htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
   4933     }
   4934   while (g);
   4935 
   4936   got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
   4937 
   4938   needed_relocs = 0;
   4939   for (g = gg->next; g && g->next != gg; g = g->next)
   4940     {
   4941       unsigned int save_assign;
   4942 
   4943       /* Assign offsets to global GOT entries and count how many
   4944 	 relocations they need.  */
   4945       save_assign = g->assigned_low_gotno;
   4946       g->assigned_low_gotno = g->local_gotno;
   4947       tga.info = info;
   4948       tga.value = MIPS_ELF_GOT_SIZE (abfd);
   4949       tga.g = g;
   4950       htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
   4951       if (!tga.g)
   4952 	return FALSE;
   4953       BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno);
   4954       g->assigned_low_gotno = save_assign;
   4955 
   4956       if (info->shared)
   4957 	{
   4958 	  g->relocs += g->local_gotno - g->assigned_low_gotno;
   4959 	  BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno
   4960 		      + g->next->global_gotno
   4961 		      + g->next->tls_gotno
   4962 		      + htab->reserved_gotno);
   4963 	}
   4964       needed_relocs += g->relocs;
   4965     }
   4966   needed_relocs += g->relocs;
   4967 
   4968   if (needed_relocs)
   4969     mips_elf_allocate_dynamic_relocations (dynobj, info,
   4970 					   needed_relocs);
   4971 
   4972   return TRUE;
   4973 }
   4974 
   4975 
   4976 /* Returns the first relocation of type r_type found, beginning with
   4978    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
   4979 
   4980 static const Elf_Internal_Rela *
   4981 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
   4982 			  const Elf_Internal_Rela *relocation,
   4983 			  const Elf_Internal_Rela *relend)
   4984 {
   4985   unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
   4986 
   4987   while (relocation < relend)
   4988     {
   4989       if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
   4990 	  && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
   4991 	return relocation;
   4992 
   4993       ++relocation;
   4994     }
   4995 
   4996   /* We didn't find it.  */
   4997   return NULL;
   4998 }
   4999 
   5000 /* Return whether an input relocation is against a local symbol.  */
   5001 
   5002 static bfd_boolean
   5003 mips_elf_local_relocation_p (bfd *input_bfd,
   5004 			     const Elf_Internal_Rela *relocation,
   5005 			     asection **local_sections)
   5006 {
   5007   unsigned long r_symndx;
   5008   Elf_Internal_Shdr *symtab_hdr;
   5009   size_t extsymoff;
   5010 
   5011   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
   5012   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   5013   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
   5014 
   5015   if (r_symndx < extsymoff)
   5016     return TRUE;
   5017   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
   5018     return TRUE;
   5019 
   5020   return FALSE;
   5021 }
   5022 
   5023 /* Sign-extend VALUE, which has the indicated number of BITS.  */
   5025 
   5026 bfd_vma
   5027 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
   5028 {
   5029   if (value & ((bfd_vma) 1 << (bits - 1)))
   5030     /* VALUE is negative.  */
   5031     value |= ((bfd_vma) - 1) << bits;
   5032 
   5033   return value;
   5034 }
   5035 
   5036 /* Return non-zero if the indicated VALUE has overflowed the maximum
   5037    range expressible by a signed number with the indicated number of
   5038    BITS.  */
   5039 
   5040 static bfd_boolean
   5041 mips_elf_overflow_p (bfd_vma value, int bits)
   5042 {
   5043   bfd_signed_vma svalue = (bfd_signed_vma) value;
   5044 
   5045   if (svalue > (1 << (bits - 1)) - 1)
   5046     /* The value is too big.  */
   5047     return TRUE;
   5048   else if (svalue < -(1 << (bits - 1)))
   5049     /* The value is too small.  */
   5050     return TRUE;
   5051 
   5052   /* All is well.  */
   5053   return FALSE;
   5054 }
   5055 
   5056 /* Calculate the %high function.  */
   5057 
   5058 static bfd_vma
   5059 mips_elf_high (bfd_vma value)
   5060 {
   5061   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
   5062 }
   5063 
   5064 /* Calculate the %higher function.  */
   5065 
   5066 static bfd_vma
   5067 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
   5068 {
   5069 #ifdef BFD64
   5070   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
   5071 #else
   5072   abort ();
   5073   return MINUS_ONE;
   5074 #endif
   5075 }
   5076 
   5077 /* Calculate the %highest function.  */
   5078 
   5079 static bfd_vma
   5080 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
   5081 {
   5082 #ifdef BFD64
   5083   return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
   5084 #else
   5085   abort ();
   5086   return MINUS_ONE;
   5087 #endif
   5088 }
   5089 
   5090 /* Create the .compact_rel section.  */
   5092 
   5093 static bfd_boolean
   5094 mips_elf_create_compact_rel_section
   5095   (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
   5096 {
   5097   flagword flags;
   5098   register asection *s;
   5099 
   5100   if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
   5101     {
   5102       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
   5103 	       | SEC_READONLY);
   5104 
   5105       s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
   5106       if (s == NULL
   5107 	  || ! bfd_set_section_alignment (abfd, s,
   5108 					  MIPS_ELF_LOG_FILE_ALIGN (abfd)))
   5109 	return FALSE;
   5110 
   5111       s->size = sizeof (Elf32_External_compact_rel);
   5112     }
   5113 
   5114   return TRUE;
   5115 }
   5116 
   5117 /* Create the .got section to hold the global offset table.  */
   5118 
   5119 static bfd_boolean
   5120 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
   5121 {
   5122   flagword flags;
   5123   register asection *s;
   5124   struct elf_link_hash_entry *h;
   5125   struct bfd_link_hash_entry *bh;
   5126   struct mips_elf_link_hash_table *htab;
   5127 
   5128   htab = mips_elf_hash_table (info);
   5129   BFD_ASSERT (htab != NULL);
   5130 
   5131   /* This function may be called more than once.  */
   5132   if (htab->sgot)
   5133     return TRUE;
   5134 
   5135   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
   5136 	   | SEC_LINKER_CREATED);
   5137 
   5138   /* We have to use an alignment of 2**4 here because this is hardcoded
   5139      in the function stub generation and in the linker script.  */
   5140   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
   5141   if (s == NULL
   5142       || ! bfd_set_section_alignment (abfd, s, 4))
   5143     return FALSE;
   5144   htab->sgot = s;
   5145 
   5146   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
   5147      linker script because we don't want to define the symbol if we
   5148      are not creating a global offset table.  */
   5149   bh = NULL;
   5150   if (! (_bfd_generic_link_add_one_symbol
   5151 	 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
   5152 	  0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
   5153     return FALSE;
   5154 
   5155   h = (struct elf_link_hash_entry *) bh;
   5156   h->non_elf = 0;
   5157   h->def_regular = 1;
   5158   h->type = STT_OBJECT;
   5159   h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
   5160   elf_hash_table (info)->hgot = h;
   5161 
   5162   if (info->shared
   5163       && ! bfd_elf_link_record_dynamic_symbol (info, h))
   5164     return FALSE;
   5165 
   5166   htab->got_info = mips_elf_create_got_info (abfd);
   5167   mips_elf_section_data (s)->elf.this_hdr.sh_flags
   5168     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
   5169 
   5170   /* We also need a .got.plt section when generating PLTs.  */
   5171   s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
   5172 					  SEC_ALLOC | SEC_LOAD
   5173 					  | SEC_HAS_CONTENTS
   5174 					  | SEC_IN_MEMORY
   5175 					  | SEC_LINKER_CREATED);
   5176   if (s == NULL)
   5177     return FALSE;
   5178   htab->sgotplt = s;
   5179 
   5180   return TRUE;
   5181 }
   5182 
   5183 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
   5185    __GOTT_INDEX__ symbols.  These symbols are only special for
   5186    shared objects; they are not used in executables.  */
   5187 
   5188 static bfd_boolean
   5189 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
   5190 {
   5191   return (mips_elf_hash_table (info)->is_vxworks
   5192 	  && info->shared
   5193 	  && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
   5194 	      || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
   5195 }
   5196 
   5197 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
   5198    require an la25 stub.  See also mips_elf_local_pic_function_p,
   5199    which determines whether the destination function ever requires a
   5200    stub.  */
   5201 
   5202 static bfd_boolean
   5203 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
   5204 				     bfd_boolean target_is_16_bit_code_p)
   5205 {
   5206   /* We specifically ignore branches and jumps from EF_PIC objects,
   5207      where the onus is on the compiler or programmer to perform any
   5208      necessary initialization of $25.  Sometimes such initialization
   5209      is unnecessary; for example, -mno-shared functions do not use
   5210      the incoming value of $25, and may therefore be called directly.  */
   5211   if (PIC_OBJECT_P (input_bfd))
   5212     return FALSE;
   5213 
   5214   switch (r_type)
   5215     {
   5216     case R_MIPS_26:
   5217     case R_MIPS_PC16:
   5218     case R_MIPS_PC21_S2:
   5219     case R_MIPS_PC26_S2:
   5220     case R_MICROMIPS_26_S1:
   5221     case R_MICROMIPS_PC7_S1:
   5222     case R_MICROMIPS_PC10_S1:
   5223     case R_MICROMIPS_PC16_S1:
   5224     case R_MICROMIPS_PC23_S2:
   5225       return TRUE;
   5226 
   5227     case R_MIPS16_26:
   5228       return !target_is_16_bit_code_p;
   5229 
   5230     default:
   5231       return FALSE;
   5232     }
   5233 }
   5234 
   5235 /* Calculate the value produced by the RELOCATION (which comes from
   5237    the INPUT_BFD).  The ADDEND is the addend to use for this
   5238    RELOCATION; RELOCATION->R_ADDEND is ignored.
   5239 
   5240    The result of the relocation calculation is stored in VALUEP.
   5241    On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
   5242    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
   5243 
   5244    This function returns bfd_reloc_continue if the caller need take no
   5245    further action regarding this relocation, bfd_reloc_notsupported if
   5246    something goes dramatically wrong, bfd_reloc_overflow if an
   5247    overflow occurs, and bfd_reloc_ok to indicate success.  */
   5248 
   5249 static bfd_reloc_status_type
   5250 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
   5251 			       asection *input_section,
   5252 			       struct bfd_link_info *info,
   5253 			       const Elf_Internal_Rela *relocation,
   5254 			       bfd_vma addend, reloc_howto_type *howto,
   5255 			       Elf_Internal_Sym *local_syms,
   5256 			       asection **local_sections, bfd_vma *valuep,
   5257 			       const char **namep,
   5258 			       bfd_boolean *cross_mode_jump_p,
   5259 			       bfd_boolean save_addend)
   5260 {
   5261   /* The eventual value we will return.  */
   5262   bfd_vma value;
   5263   /* The address of the symbol against which the relocation is
   5264      occurring.  */
   5265   bfd_vma symbol = 0;
   5266   /* The final GP value to be used for the relocatable, executable, or
   5267      shared object file being produced.  */
   5268   bfd_vma gp;
   5269   /* The place (section offset or address) of the storage unit being
   5270      relocated.  */
   5271   bfd_vma p;
   5272   /* The value of GP used to create the relocatable object.  */
   5273   bfd_vma gp0;
   5274   /* The offset into the global offset table at which the address of
   5275      the relocation entry symbol, adjusted by the addend, resides
   5276      during execution.  */
   5277   bfd_vma g = MINUS_ONE;
   5278   /* The section in which the symbol referenced by the relocation is
   5279      located.  */
   5280   asection *sec = NULL;
   5281   struct mips_elf_link_hash_entry *h = NULL;
   5282   /* TRUE if the symbol referred to by this relocation is a local
   5283      symbol.  */
   5284   bfd_boolean local_p, was_local_p;
   5285   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
   5286   bfd_boolean gp_disp_p = FALSE;
   5287   /* TRUE if the symbol referred to by this relocation is
   5288      "__gnu_local_gp".  */
   5289   bfd_boolean gnu_local_gp_p = FALSE;
   5290   Elf_Internal_Shdr *symtab_hdr;
   5291   size_t extsymoff;
   5292   unsigned long r_symndx;
   5293   int r_type;
   5294   /* TRUE if overflow occurred during the calculation of the
   5295      relocation value.  */
   5296   bfd_boolean overflowed_p;
   5297   /* TRUE if this relocation refers to a MIPS16 function.  */
   5298   bfd_boolean target_is_16_bit_code_p = FALSE;
   5299   bfd_boolean target_is_micromips_code_p = FALSE;
   5300   struct mips_elf_link_hash_table *htab;
   5301   bfd *dynobj;
   5302 
   5303   dynobj = elf_hash_table (info)->dynobj;
   5304   htab = mips_elf_hash_table (info);
   5305   BFD_ASSERT (htab != NULL);
   5306 
   5307   /* Parse the relocation.  */
   5308   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
   5309   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
   5310   p = (input_section->output_section->vma
   5311        + input_section->output_offset
   5312        + relocation->r_offset);
   5313 
   5314   /* Assume that there will be no overflow.  */
   5315   overflowed_p = FALSE;
   5316 
   5317   /* Figure out whether or not the symbol is local, and get the offset
   5318      used in the array of hash table entries.  */
   5319   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   5320   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
   5321 					 local_sections);
   5322   was_local_p = local_p;
   5323   if (! elf_bad_symtab (input_bfd))
   5324     extsymoff = symtab_hdr->sh_info;
   5325   else
   5326     {
   5327       /* The symbol table does not follow the rule that local symbols
   5328 	 must come before globals.  */
   5329       extsymoff = 0;
   5330     }
   5331 
   5332   /* Figure out the value of the symbol.  */
   5333   if (local_p)
   5334     {
   5335       Elf_Internal_Sym *sym;
   5336 
   5337       sym = local_syms + r_symndx;
   5338       sec = local_sections[r_symndx];
   5339 
   5340       symbol = sec->output_section->vma + sec->output_offset;
   5341       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
   5342 	  || (sec->flags & SEC_MERGE))
   5343 	symbol += sym->st_value;
   5344       if ((sec->flags & SEC_MERGE)
   5345 	  && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
   5346 	{
   5347 	  addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
   5348 	  addend -= symbol;
   5349 	  addend += sec->output_section->vma + sec->output_offset;
   5350 	}
   5351 
   5352       /* MIPS16/microMIPS text labels should be treated as odd.  */
   5353       if (ELF_ST_IS_COMPRESSED (sym->st_other))
   5354 	++symbol;
   5355 
   5356       /* Record the name of this symbol, for our caller.  */
   5357       *namep = bfd_elf_string_from_elf_section (input_bfd,
   5358 						symtab_hdr->sh_link,
   5359 						sym->st_name);
   5360       if (*namep == '\0')
   5361 	*namep = bfd_section_name (input_bfd, sec);
   5362 
   5363       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
   5364       target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
   5365     }
   5366   else
   5367     {
   5368       /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
   5369 
   5370       /* For global symbols we look up the symbol in the hash-table.  */
   5371       h = ((struct mips_elf_link_hash_entry *)
   5372 	   elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
   5373       /* Find the real hash-table entry for this symbol.  */
   5374       while (h->root.root.type == bfd_link_hash_indirect
   5375 	     || h->root.root.type == bfd_link_hash_warning)
   5376 	h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
   5377 
   5378       /* Record the name of this symbol, for our caller.  */
   5379       *namep = h->root.root.root.string;
   5380 
   5381       /* See if this is the special _gp_disp symbol.  Note that such a
   5382 	 symbol must always be a global symbol.  */
   5383       if (strcmp (*namep, "_gp_disp") == 0
   5384 	  && ! NEWABI_P (input_bfd))
   5385 	{
   5386 	  /* Relocations against _gp_disp are permitted only with
   5387 	     R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
   5388 	  if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
   5389 	    return bfd_reloc_notsupported;
   5390 
   5391 	  gp_disp_p = TRUE;
   5392 	}
   5393       /* See if this is the special _gp symbol.  Note that such a
   5394 	 symbol must always be a global symbol.  */
   5395       else if (strcmp (*namep, "__gnu_local_gp") == 0)
   5396 	gnu_local_gp_p = TRUE;
   5397 
   5398 
   5399       /* If this symbol is defined, calculate its address.  Note that
   5400 	 _gp_disp is a magic symbol, always implicitly defined by the
   5401 	 linker, so it's inappropriate to check to see whether or not
   5402 	 its defined.  */
   5403       else if ((h->root.root.type == bfd_link_hash_defined
   5404 		|| h->root.root.type == bfd_link_hash_defweak)
   5405 	       && h->root.root.u.def.section)
   5406 	{
   5407 	  sec = h->root.root.u.def.section;
   5408 	  if (sec->output_section)
   5409 	    symbol = (h->root.root.u.def.value
   5410 		      + sec->output_section->vma
   5411 		      + sec->output_offset);
   5412 	  else
   5413 	    symbol = h->root.root.u.def.value;
   5414 	}
   5415       else if (h->root.root.type == bfd_link_hash_undefweak)
   5416 	/* We allow relocations against undefined weak symbols, giving
   5417 	   it the value zero, so that you can undefined weak functions
   5418 	   and check to see if they exist by looking at their
   5419 	   addresses.  */
   5420 	symbol = 0;
   5421       else if (info->unresolved_syms_in_objects == RM_IGNORE
   5422 	       && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
   5423 	symbol = 0;
   5424       else if (strcmp (*namep, SGI_COMPAT (input_bfd)
   5425 		       ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
   5426 	{
   5427 	  /* If this is a dynamic link, we should have created a
   5428 	     _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
   5429 	     in in _bfd_mips_elf_create_dynamic_sections.
   5430 	     Otherwise, we should define the symbol with a value of 0.
   5431 	     FIXME: It should probably get into the symbol table
   5432 	     somehow as well.  */
   5433 	  BFD_ASSERT (! info->shared);
   5434 	  BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
   5435 	  symbol = 0;
   5436 	}
   5437       else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
   5438 	{
   5439 	  /* This is an optional symbol - an Irix specific extension to the
   5440 	     ELF spec.  Ignore it for now.
   5441 	     XXX - FIXME - there is more to the spec for OPTIONAL symbols
   5442 	     than simply ignoring them, but we do not handle this for now.
   5443 	     For information see the "64-bit ELF Object File Specification"
   5444 	     which is available from here:
   5445 	     http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
   5446 	  symbol = 0;
   5447 	}
   5448       else if ((*info->callbacks->undefined_symbol)
   5449 	       (info, h->root.root.root.string, input_bfd,
   5450 		input_section, relocation->r_offset,
   5451 		(info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
   5452 		 || ELF_ST_VISIBILITY (h->root.other)))
   5453 	{
   5454 	  return bfd_reloc_undefined;
   5455 	}
   5456       else
   5457 	{
   5458 	  return bfd_reloc_notsupported;
   5459 	}
   5460 
   5461       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
   5462       target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other);
   5463     }
   5464 
   5465   /* If this is a reference to a 16-bit function with a stub, we need
   5466      to redirect the relocation to the stub unless:
   5467 
   5468      (a) the relocation is for a MIPS16 JAL;
   5469 
   5470      (b) the relocation is for a MIPS16 PIC call, and there are no
   5471 	 non-MIPS16 uses of the GOT slot; or
   5472 
   5473      (c) the section allows direct references to MIPS16 functions.  */
   5474   if (r_type != R_MIPS16_26
   5475       && !info->relocatable
   5476       && ((h != NULL
   5477 	   && h->fn_stub != NULL
   5478 	   && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
   5479 	  || (local_p
   5480 	      && mips_elf_tdata (input_bfd)->local_stubs != NULL
   5481 	      && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
   5482       && !section_allows_mips16_refs_p (input_section))
   5483     {
   5484       /* This is a 32- or 64-bit call to a 16-bit function.  We should
   5485 	 have already noticed that we were going to need the
   5486 	 stub.  */
   5487       if (local_p)
   5488 	{
   5489 	  sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx];
   5490 	  value = 0;
   5491 	}
   5492       else
   5493 	{
   5494 	  BFD_ASSERT (h->need_fn_stub);
   5495 	  if (h->la25_stub)
   5496 	    {
   5497 	      /* If a LA25 header for the stub itself exists, point to the
   5498 		 prepended LUI/ADDIU sequence.  */
   5499 	      sec = h->la25_stub->stub_section;
   5500 	      value = h->la25_stub->offset;
   5501 	    }
   5502 	  else
   5503 	    {
   5504 	      sec = h->fn_stub;
   5505 	      value = 0;
   5506 	    }
   5507 	}
   5508 
   5509       symbol = sec->output_section->vma + sec->output_offset + value;
   5510       /* The target is 16-bit, but the stub isn't.  */
   5511       target_is_16_bit_code_p = FALSE;
   5512     }
   5513   /* If this is a MIPS16 call with a stub, that is made through the PLT or
   5514      to a standard MIPS function, we need to redirect the call to the stub.
   5515      Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
   5516      indirect calls should use an indirect stub instead.  */
   5517   else if (r_type == R_MIPS16_26 && !info->relocatable
   5518 	   && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
   5519 	       || (local_p
   5520 		   && mips_elf_tdata (input_bfd)->local_call_stubs != NULL
   5521 		   && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
   5522 	   && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p))
   5523     {
   5524       if (local_p)
   5525 	sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx];
   5526       else
   5527 	{
   5528 	  /* If both call_stub and call_fp_stub are defined, we can figure
   5529 	     out which one to use by checking which one appears in the input
   5530 	     file.  */
   5531 	  if (h->call_stub != NULL && h->call_fp_stub != NULL)
   5532 	    {
   5533 	      asection *o;
   5534 
   5535 	      sec = NULL;
   5536 	      for (o = input_bfd->sections; o != NULL; o = o->next)
   5537 		{
   5538 		  if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
   5539 		    {
   5540 		      sec = h->call_fp_stub;
   5541 		      break;
   5542 		    }
   5543 		}
   5544 	      if (sec == NULL)
   5545 		sec = h->call_stub;
   5546 	    }
   5547 	  else if (h->call_stub != NULL)
   5548 	    sec = h->call_stub;
   5549 	  else
   5550 	    sec = h->call_fp_stub;
   5551   	}
   5552 
   5553       BFD_ASSERT (sec->size > 0);
   5554       symbol = sec->output_section->vma + sec->output_offset;
   5555     }
   5556   /* If this is a direct call to a PIC function, redirect to the
   5557      non-PIC stub.  */
   5558   else if (h != NULL && h->la25_stub
   5559 	   && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
   5560 						   target_is_16_bit_code_p))
   5561     symbol = (h->la25_stub->stub_section->output_section->vma
   5562 	      + h->la25_stub->stub_section->output_offset
   5563 	      + h->la25_stub->offset);
   5564   /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
   5565      entry is used if a standard PLT entry has also been made.  In this
   5566      case the symbol will have been set by mips_elf_set_plt_sym_value
   5567      to point to the standard PLT entry, so redirect to the compressed
   5568      one.  */
   5569   else if ((r_type == R_MIPS16_26 || r_type == R_MICROMIPS_26_S1)
   5570 	   && !info->relocatable
   5571 	   && h != NULL
   5572 	   && h->use_plt_entry
   5573 	   && h->root.plt.plist->comp_offset != MINUS_ONE
   5574 	   && h->root.plt.plist->mips_offset != MINUS_ONE)
   5575     {
   5576       bfd_boolean micromips_p = MICROMIPS_P (abfd);
   5577 
   5578       sec = htab->splt;
   5579       symbol = (sec->output_section->vma
   5580 		+ sec->output_offset
   5581 		+ htab->plt_header_size
   5582 		+ htab->plt_mips_offset
   5583 		+ h->root.plt.plist->comp_offset
   5584 		+ 1);
   5585 
   5586       target_is_16_bit_code_p = !micromips_p;
   5587       target_is_micromips_code_p = micromips_p;
   5588     }
   5589 
   5590   /* Make sure MIPS16 and microMIPS are not used together.  */
   5591   if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
   5592       || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
   5593    {
   5594       (*_bfd_error_handler)
   5595 	(_("MIPS16 and microMIPS functions cannot call each other"));
   5596       return bfd_reloc_notsupported;
   5597    }
   5598 
   5599   /* Calls from 16-bit code to 32-bit code and vice versa require the
   5600      mode change.  However, we can ignore calls to undefined weak symbols,
   5601      which should never be executed at runtime.  This exception is important
   5602      because the assembly writer may have "known" that any definition of the
   5603      symbol would be 16-bit code, and that direct jumps were therefore
   5604      acceptable.  */
   5605   *cross_mode_jump_p = (!info->relocatable
   5606 			&& !(h && h->root.root.type == bfd_link_hash_undefweak)
   5607 			&& ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
   5608 			    || (r_type == R_MICROMIPS_26_S1
   5609 				&& !target_is_micromips_code_p)
   5610 			    || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
   5611 				&& (target_is_16_bit_code_p
   5612 				    || target_is_micromips_code_p))));
   5613 
   5614   local_p = (h == NULL || mips_use_local_got_p (info, h));
   5615 
   5616   gp0 = _bfd_get_gp_value (input_bfd);
   5617   gp = _bfd_get_gp_value (abfd);
   5618   if (htab->got_info)
   5619     gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
   5620 
   5621   if (gnu_local_gp_p)
   5622     symbol = gp;
   5623 
   5624   /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
   5625      to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
   5626      corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.  */
   5627   if (got_page_reloc_p (r_type) && !local_p)
   5628     {
   5629       r_type = (micromips_reloc_p (r_type)
   5630 		? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
   5631       addend = 0;
   5632     }
   5633 
   5634   /* If we haven't already determined the GOT offset, and we're going
   5635      to need it, get it now.  */
   5636   switch (r_type)
   5637     {
   5638     case R_MIPS16_CALL16:
   5639     case R_MIPS16_GOT16:
   5640     case R_MIPS_CALL16:
   5641     case R_MIPS_GOT16:
   5642     case R_MIPS_GOT_DISP:
   5643     case R_MIPS_GOT_HI16:
   5644     case R_MIPS_CALL_HI16:
   5645     case R_MIPS_GOT_LO16:
   5646     case R_MIPS_CALL_LO16:
   5647     case R_MICROMIPS_CALL16:
   5648     case R_MICROMIPS_GOT16:
   5649     case R_MICROMIPS_GOT_DISP:
   5650     case R_MICROMIPS_GOT_HI16:
   5651     case R_MICROMIPS_CALL_HI16:
   5652     case R_MICROMIPS_GOT_LO16:
   5653     case R_MICROMIPS_CALL_LO16:
   5654     case R_MIPS_TLS_GD:
   5655     case R_MIPS_TLS_GOTTPREL:
   5656     case R_MIPS_TLS_LDM:
   5657     case R_MIPS16_TLS_GD:
   5658     case R_MIPS16_TLS_GOTTPREL:
   5659     case R_MIPS16_TLS_LDM:
   5660     case R_MICROMIPS_TLS_GD:
   5661     case R_MICROMIPS_TLS_GOTTPREL:
   5662     case R_MICROMIPS_TLS_LDM:
   5663       /* Find the index into the GOT where this value is located.  */
   5664       if (tls_ldm_reloc_p (r_type))
   5665 	{
   5666 	  g = mips_elf_local_got_index (abfd, input_bfd, info,
   5667 					0, 0, NULL, r_type);
   5668 	  if (g == MINUS_ONE)
   5669 	    return bfd_reloc_outofrange;
   5670 	}
   5671       else if (!local_p)
   5672 	{
   5673 	  /* On VxWorks, CALL relocations should refer to the .got.plt
   5674 	     entry, which is initialized to point at the PLT stub.  */
   5675 	  if (htab->is_vxworks
   5676 	      && (call_hi16_reloc_p (r_type)
   5677 		  || call_lo16_reloc_p (r_type)
   5678 		  || call16_reloc_p (r_type)))
   5679 	    {
   5680 	      BFD_ASSERT (addend == 0);
   5681 	      BFD_ASSERT (h->root.needs_plt);
   5682 	      g = mips_elf_gotplt_index (info, &h->root);
   5683 	    }
   5684 	  else
   5685 	    {
   5686 	      BFD_ASSERT (addend == 0);
   5687 	      g = mips_elf_global_got_index (abfd, info, input_bfd,
   5688 					     &h->root, r_type);
   5689 	      if (!TLS_RELOC_P (r_type)
   5690 		  && !elf_hash_table (info)->dynamic_sections_created)
   5691 		/* This is a static link.  We must initialize the GOT entry.  */
   5692 		MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
   5693 	    }
   5694 	}
   5695       else if (!htab->is_vxworks
   5696 	       && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
   5697 	/* The calculation below does not involve "g".  */
   5698 	break;
   5699       else
   5700 	{
   5701 	  g = mips_elf_local_got_index (abfd, input_bfd, info,
   5702 					symbol + addend, r_symndx, h, r_type);
   5703 	  if (g == MINUS_ONE)
   5704 	    return bfd_reloc_outofrange;
   5705 	}
   5706 
   5707       /* Convert GOT indices to actual offsets.  */
   5708       g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
   5709       break;
   5710     }
   5711 
   5712   /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
   5713      symbols are resolved by the loader.  Add them to .rela.dyn.  */
   5714   if (h != NULL && is_gott_symbol (info, &h->root))
   5715     {
   5716       Elf_Internal_Rela outrel;
   5717       bfd_byte *loc;
   5718       asection *s;
   5719 
   5720       s = mips_elf_rel_dyn_section (info, FALSE);
   5721       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
   5722 
   5723       outrel.r_offset = (input_section->output_section->vma
   5724 			 + input_section->output_offset
   5725 			 + relocation->r_offset);
   5726       outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
   5727       outrel.r_addend = addend;
   5728       bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
   5729 
   5730       /* If we've written this relocation for a readonly section,
   5731 	 we need to set DF_TEXTREL again, so that we do not delete the
   5732 	 DT_TEXTREL tag.  */
   5733       if (MIPS_ELF_READONLY_SECTION (input_section))
   5734 	info->flags |= DF_TEXTREL;
   5735 
   5736       *valuep = 0;
   5737       return bfd_reloc_ok;
   5738     }
   5739 
   5740   /* Figure out what kind of relocation is being performed.  */
   5741   switch (r_type)
   5742     {
   5743     case R_MIPS_NONE:
   5744       return bfd_reloc_continue;
   5745 
   5746     case R_MIPS_16:
   5747       if (howto->partial_inplace)
   5748 	addend = _bfd_mips_elf_sign_extend (addend, 16);
   5749       value = symbol + addend;
   5750       overflowed_p = mips_elf_overflow_p (value, 16);
   5751       break;
   5752 
   5753     case R_MIPS_32:
   5754     case R_MIPS_REL32:
   5755     case R_MIPS_64:
   5756       if ((info->shared
   5757 	   || (htab->root.dynamic_sections_created
   5758 	       && h != NULL
   5759 	       && h->root.def_dynamic
   5760 	       && !h->root.def_regular
   5761 	       && !h->has_static_relocs))
   5762 	  && r_symndx != STN_UNDEF
   5763 	  && (h == NULL
   5764 	      || h->root.root.type != bfd_link_hash_undefweak
   5765 	      || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
   5766 	  && (input_section->flags & SEC_ALLOC) != 0)
   5767 	{
   5768 	  /* If we're creating a shared library, then we can't know
   5769 	     where the symbol will end up.  So, we create a relocation
   5770 	     record in the output, and leave the job up to the dynamic
   5771 	     linker.  We must do the same for executable references to
   5772 	     shared library symbols, unless we've decided to use copy
   5773 	     relocs or PLTs instead.  */
   5774 	  value = addend;
   5775 	  if (!mips_elf_create_dynamic_relocation (abfd,
   5776 						   info,
   5777 						   relocation,
   5778 						   h,
   5779 						   sec,
   5780 						   symbol,
   5781 						   &value,
   5782 						   input_section))
   5783 	    return bfd_reloc_undefined;
   5784 	}
   5785       else
   5786 	{
   5787 	  if (r_type != R_MIPS_REL32)
   5788 	    value = symbol + addend;
   5789 	  else
   5790 	    value = addend;
   5791 	}
   5792       value &= howto->dst_mask;
   5793       break;
   5794 
   5795     case R_MIPS_PC32:
   5796       value = symbol + addend - p;
   5797       value &= howto->dst_mask;
   5798       break;
   5799 
   5800     case R_MIPS16_26:
   5801       /* The calculation for R_MIPS16_26 is just the same as for an
   5802 	 R_MIPS_26.  It's only the storage of the relocated field into
   5803 	 the output file that's different.  That's handled in
   5804 	 mips_elf_perform_relocation.  So, we just fall through to the
   5805 	 R_MIPS_26 case here.  */
   5806     case R_MIPS_26:
   5807     case R_MICROMIPS_26_S1:
   5808       {
   5809 	unsigned int shift;
   5810 
   5811 	/* Make sure the target of JALX is word-aligned.  Bit 0 must be
   5812 	   the correct ISA mode selector and bit 1 must be 0.  */
   5813 	if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
   5814 	  return bfd_reloc_outofrange;
   5815 
   5816 	/* Shift is 2, unusually, for microMIPS JALX.  */
   5817 	shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
   5818 
   5819 	if (was_local_p)
   5820 	  value = addend | ((p + 4) & (0xfc000000 << shift));
   5821 	else if (howto->partial_inplace)
   5822 	  value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
   5823 	else
   5824 	  value = addend;
   5825 	value = (value + symbol) >> shift;
   5826 	if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
   5827 	  overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
   5828 	value &= howto->dst_mask;
   5829       }
   5830       break;
   5831 
   5832     case R_MIPS_TLS_DTPREL_HI16:
   5833     case R_MIPS16_TLS_DTPREL_HI16:
   5834     case R_MICROMIPS_TLS_DTPREL_HI16:
   5835       value = (mips_elf_high (addend + symbol - dtprel_base (info))
   5836 	       & howto->dst_mask);
   5837       break;
   5838 
   5839     case R_MIPS_TLS_DTPREL_LO16:
   5840     case R_MIPS_TLS_DTPREL32:
   5841     case R_MIPS_TLS_DTPREL64:
   5842     case R_MIPS16_TLS_DTPREL_LO16:
   5843     case R_MICROMIPS_TLS_DTPREL_LO16:
   5844       value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
   5845       break;
   5846 
   5847     case R_MIPS_TLS_TPREL_HI16:
   5848     case R_MIPS16_TLS_TPREL_HI16:
   5849     case R_MICROMIPS_TLS_TPREL_HI16:
   5850       value = (mips_elf_high (addend + symbol - tprel_base (info))
   5851 	       & howto->dst_mask);
   5852       break;
   5853 
   5854     case R_MIPS_TLS_TPREL_LO16:
   5855     case R_MIPS_TLS_TPREL32:
   5856     case R_MIPS_TLS_TPREL64:
   5857     case R_MIPS16_TLS_TPREL_LO16:
   5858     case R_MICROMIPS_TLS_TPREL_LO16:
   5859       value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
   5860       break;
   5861 
   5862     case R_MIPS_HI16:
   5863     case R_MIPS16_HI16:
   5864     case R_MICROMIPS_HI16:
   5865       if (!gp_disp_p)
   5866 	{
   5867 	  value = mips_elf_high (addend + symbol);
   5868 	  value &= howto->dst_mask;
   5869 	}
   5870       else
   5871 	{
   5872 	  /* For MIPS16 ABI code we generate this sequence
   5873 	        0: li      $v0,%hi(_gp_disp)
   5874 	        4: addiupc $v1,%lo(_gp_disp)
   5875 	        8: sll     $v0,16
   5876 	       12: addu    $v0,$v1
   5877 	       14: move    $gp,$v0
   5878 	     So the offsets of hi and lo relocs are the same, but the
   5879 	     base $pc is that used by the ADDIUPC instruction at $t9 + 4.
   5880 	     ADDIUPC clears the low two bits of the instruction address,
   5881 	     so the base is ($t9 + 4) & ~3.  */
   5882 	  if (r_type == R_MIPS16_HI16)
   5883 	    value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
   5884 	  /* The microMIPS .cpload sequence uses the same assembly
   5885 	     instructions as the traditional psABI version, but the
   5886 	     incoming $t9 has the low bit set.  */
   5887 	  else if (r_type == R_MICROMIPS_HI16)
   5888 	    value = mips_elf_high (addend + gp - p - 1);
   5889 	  else
   5890 	    value = mips_elf_high (addend + gp - p);
   5891 	  overflowed_p = mips_elf_overflow_p (value, 16);
   5892 	}
   5893       break;
   5894 
   5895     case R_MIPS_LO16:
   5896     case R_MIPS16_LO16:
   5897     case R_MICROMIPS_LO16:
   5898     case R_MICROMIPS_HI0_LO16:
   5899       if (!gp_disp_p)
   5900 	value = (symbol + addend) & howto->dst_mask;
   5901       else
   5902 	{
   5903 	  /* See the comment for R_MIPS16_HI16 above for the reason
   5904 	     for this conditional.  */
   5905 	  if (r_type == R_MIPS16_LO16)
   5906 	    value = addend + gp - (p & ~(bfd_vma) 0x3);
   5907 	  else if (r_type == R_MICROMIPS_LO16
   5908 		   || r_type == R_MICROMIPS_HI0_LO16)
   5909 	    value = addend + gp - p + 3;
   5910 	  else
   5911 	    value = addend + gp - p + 4;
   5912 	  /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
   5913 	     for overflow.  But, on, say, IRIX5, relocations against
   5914 	     _gp_disp are normally generated from the .cpload
   5915 	     pseudo-op.  It generates code that normally looks like
   5916 	     this:
   5917 
   5918 	       lui    $gp,%hi(_gp_disp)
   5919 	       addiu  $gp,$gp,%lo(_gp_disp)
   5920 	       addu   $gp,$gp,$t9
   5921 
   5922 	     Here $t9 holds the address of the function being called,
   5923 	     as required by the MIPS ELF ABI.  The R_MIPS_LO16
   5924 	     relocation can easily overflow in this situation, but the
   5925 	     R_MIPS_HI16 relocation will handle the overflow.
   5926 	     Therefore, we consider this a bug in the MIPS ABI, and do
   5927 	     not check for overflow here.  */
   5928 	}
   5929       break;
   5930 
   5931     case R_MIPS_LITERAL:
   5932     case R_MICROMIPS_LITERAL:
   5933       /* Because we don't merge literal sections, we can handle this
   5934 	 just like R_MIPS_GPREL16.  In the long run, we should merge
   5935 	 shared literals, and then we will need to additional work
   5936 	 here.  */
   5937 
   5938       /* Fall through.  */
   5939 
   5940     case R_MIPS16_GPREL:
   5941       /* The R_MIPS16_GPREL performs the same calculation as
   5942 	 R_MIPS_GPREL16, but stores the relocated bits in a different
   5943 	 order.  We don't need to do anything special here; the
   5944 	 differences are handled in mips_elf_perform_relocation.  */
   5945     case R_MIPS_GPREL16:
   5946     case R_MICROMIPS_GPREL7_S2:
   5947     case R_MICROMIPS_GPREL16:
   5948       /* Only sign-extend the addend if it was extracted from the
   5949 	 instruction.  If the addend was separate, leave it alone,
   5950 	 otherwise we may lose significant bits.  */
   5951       if (howto->partial_inplace)
   5952 	addend = _bfd_mips_elf_sign_extend (addend, 16);
   5953       value = symbol + addend - gp;
   5954       /* If the symbol was local, any earlier relocatable links will
   5955 	 have adjusted its addend with the gp offset, so compensate
   5956 	 for that now.  Don't do it for symbols forced local in this
   5957 	 link, though, since they won't have had the gp offset applied
   5958 	 to them before.  */
   5959       if (was_local_p)
   5960 	value += gp0;
   5961       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   5962 	overflowed_p = mips_elf_overflow_p (value, 16);
   5963       break;
   5964 
   5965     case R_MIPS16_GOT16:
   5966     case R_MIPS16_CALL16:
   5967     case R_MIPS_GOT16:
   5968     case R_MIPS_CALL16:
   5969     case R_MICROMIPS_GOT16:
   5970     case R_MICROMIPS_CALL16:
   5971       /* VxWorks does not have separate local and global semantics for
   5972 	 R_MIPS*_GOT16; every relocation evaluates to "G".  */
   5973       if (!htab->is_vxworks && local_p)
   5974 	{
   5975 	  value = mips_elf_got16_entry (abfd, input_bfd, info,
   5976 					symbol + addend, !was_local_p);
   5977 	  if (value == MINUS_ONE)
   5978 	    return bfd_reloc_outofrange;
   5979 	  value
   5980 	    = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
   5981 	  overflowed_p = mips_elf_overflow_p (value, 16);
   5982 	  break;
   5983 	}
   5984 
   5985       /* Fall through.  */
   5986 
   5987     case R_MIPS_TLS_GD:
   5988     case R_MIPS_TLS_GOTTPREL:
   5989     case R_MIPS_TLS_LDM:
   5990     case R_MIPS_GOT_DISP:
   5991     case R_MIPS16_TLS_GD:
   5992     case R_MIPS16_TLS_GOTTPREL:
   5993     case R_MIPS16_TLS_LDM:
   5994     case R_MICROMIPS_TLS_GD:
   5995     case R_MICROMIPS_TLS_GOTTPREL:
   5996     case R_MICROMIPS_TLS_LDM:
   5997     case R_MICROMIPS_GOT_DISP:
   5998       value = g;
   5999       overflowed_p = mips_elf_overflow_p (value, 16);
   6000       break;
   6001 
   6002     case R_MIPS_GPREL32:
   6003       value = (addend + symbol + gp0 - gp);
   6004       if (!save_addend)
   6005 	value &= howto->dst_mask;
   6006       break;
   6007 
   6008     case R_MIPS_PC16:
   6009     case R_MIPS_GNU_REL16_S2:
   6010       if (howto->partial_inplace)
   6011 	addend = _bfd_mips_elf_sign_extend (addend, 18);
   6012 
   6013       if ((symbol + addend) & 3)
   6014 	return bfd_reloc_outofrange;
   6015 
   6016       value = symbol + addend - p;
   6017       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6018 	overflowed_p = mips_elf_overflow_p (value, 18);
   6019       value >>= howto->rightshift;
   6020       value &= howto->dst_mask;
   6021       break;
   6022 
   6023     case R_MIPS_PC21_S2:
   6024       if (howto->partial_inplace)
   6025 	addend = _bfd_mips_elf_sign_extend (addend, 23);
   6026 
   6027       if ((symbol + addend) & 3)
   6028 	return bfd_reloc_outofrange;
   6029 
   6030       value = symbol + addend - p;
   6031       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6032 	overflowed_p = mips_elf_overflow_p (value, 23);
   6033       value >>= howto->rightshift;
   6034       value &= howto->dst_mask;
   6035       break;
   6036 
   6037     case R_MIPS_PC26_S2:
   6038       if (howto->partial_inplace)
   6039 	addend = _bfd_mips_elf_sign_extend (addend, 28);
   6040 
   6041       if ((symbol + addend) & 3)
   6042 	return bfd_reloc_outofrange;
   6043 
   6044       value = symbol + addend - p;
   6045       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6046 	overflowed_p = mips_elf_overflow_p (value, 28);
   6047       value >>= howto->rightshift;
   6048       value &= howto->dst_mask;
   6049       break;
   6050 
   6051     case R_MIPS_PC18_S3:
   6052       if (howto->partial_inplace)
   6053 	addend = _bfd_mips_elf_sign_extend (addend, 21);
   6054 
   6055       if ((symbol + addend) & 7)
   6056 	return bfd_reloc_outofrange;
   6057 
   6058       value = symbol + addend - ((p | 7) ^ 7);
   6059       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6060 	overflowed_p = mips_elf_overflow_p (value, 21);
   6061       value >>= howto->rightshift;
   6062       value &= howto->dst_mask;
   6063       break;
   6064 
   6065     case R_MIPS_PC19_S2:
   6066       if (howto->partial_inplace)
   6067 	addend = _bfd_mips_elf_sign_extend (addend, 21);
   6068 
   6069       if ((symbol + addend) & 3)
   6070 	return bfd_reloc_outofrange;
   6071 
   6072       value = symbol + addend - p;
   6073       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6074 	overflowed_p = mips_elf_overflow_p (value, 21);
   6075       value >>= howto->rightshift;
   6076       value &= howto->dst_mask;
   6077       break;
   6078 
   6079     case R_MIPS_PCHI16:
   6080       value = mips_elf_high (symbol + addend - p);
   6081       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6082 	overflowed_p = mips_elf_overflow_p (value, 16);
   6083       value &= howto->dst_mask;
   6084       break;
   6085 
   6086     case R_MIPS_PCLO16:
   6087       if (howto->partial_inplace)
   6088 	addend = _bfd_mips_elf_sign_extend (addend, 16);
   6089       value = symbol + addend - p;
   6090       value &= howto->dst_mask;
   6091       break;
   6092 
   6093     case R_MICROMIPS_PC7_S1:
   6094       if (howto->partial_inplace)
   6095 	addend = _bfd_mips_elf_sign_extend (addend, 8);
   6096       value = symbol + addend - p;
   6097       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6098 	overflowed_p = mips_elf_overflow_p (value, 8);
   6099       value >>= howto->rightshift;
   6100       value &= howto->dst_mask;
   6101       break;
   6102 
   6103     case R_MICROMIPS_PC10_S1:
   6104       if (howto->partial_inplace)
   6105 	addend = _bfd_mips_elf_sign_extend (addend, 11);
   6106       value = symbol + addend - p;
   6107       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6108 	overflowed_p = mips_elf_overflow_p (value, 11);
   6109       value >>= howto->rightshift;
   6110       value &= howto->dst_mask;
   6111       break;
   6112 
   6113     case R_MICROMIPS_PC16_S1:
   6114       if (howto->partial_inplace)
   6115 	addend = _bfd_mips_elf_sign_extend (addend, 17);
   6116       value = symbol + addend - p;
   6117       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6118 	overflowed_p = mips_elf_overflow_p (value, 17);
   6119       value >>= howto->rightshift;
   6120       value &= howto->dst_mask;
   6121       break;
   6122 
   6123     case R_MICROMIPS_PC23_S2:
   6124       if (howto->partial_inplace)
   6125 	addend = _bfd_mips_elf_sign_extend (addend, 25);
   6126       value = symbol + addend - ((p | 3) ^ 3);
   6127       if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
   6128 	overflowed_p = mips_elf_overflow_p (value, 25);
   6129       value >>= howto->rightshift;
   6130       value &= howto->dst_mask;
   6131       break;
   6132 
   6133     case R_MIPS_GOT_HI16:
   6134     case R_MIPS_CALL_HI16:
   6135     case R_MICROMIPS_GOT_HI16:
   6136     case R_MICROMIPS_CALL_HI16:
   6137       /* We're allowed to handle these two relocations identically.
   6138 	 The dynamic linker is allowed to handle the CALL relocations
   6139 	 differently by creating a lazy evaluation stub.  */
   6140       value = g;
   6141       value = mips_elf_high (value);
   6142       value &= howto->dst_mask;
   6143       break;
   6144 
   6145     case R_MIPS_GOT_LO16:
   6146     case R_MIPS_CALL_LO16:
   6147     case R_MICROMIPS_GOT_LO16:
   6148     case R_MICROMIPS_CALL_LO16:
   6149       value = g & howto->dst_mask;
   6150       break;
   6151 
   6152     case R_MIPS_GOT_PAGE:
   6153     case R_MICROMIPS_GOT_PAGE:
   6154       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
   6155       if (value == MINUS_ONE)
   6156 	return bfd_reloc_outofrange;
   6157       value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
   6158       overflowed_p = mips_elf_overflow_p (value, 16);
   6159       break;
   6160 
   6161     case R_MIPS_GOT_OFST:
   6162     case R_MICROMIPS_GOT_OFST:
   6163       if (local_p)
   6164 	mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
   6165       else
   6166 	value = addend;
   6167       overflowed_p = mips_elf_overflow_p (value, 16);
   6168       break;
   6169 
   6170     case R_MIPS_SUB:
   6171     case R_MICROMIPS_SUB:
   6172       value = symbol - addend;
   6173       value &= howto->dst_mask;
   6174       break;
   6175 
   6176     case R_MIPS_HIGHER:
   6177     case R_MICROMIPS_HIGHER:
   6178       value = mips_elf_higher (addend + symbol);
   6179       value &= howto->dst_mask;
   6180       break;
   6181 
   6182     case R_MIPS_HIGHEST:
   6183     case R_MICROMIPS_HIGHEST:
   6184       value = mips_elf_highest (addend + symbol);
   6185       value &= howto->dst_mask;
   6186       break;
   6187 
   6188     case R_MIPS_SCN_DISP:
   6189     case R_MICROMIPS_SCN_DISP:
   6190       value = symbol + addend - sec->output_offset;
   6191       value &= howto->dst_mask;
   6192       break;
   6193 
   6194     case R_MIPS_JALR:
   6195     case R_MICROMIPS_JALR:
   6196       /* This relocation is only a hint.  In some cases, we optimize
   6197 	 it into a bal instruction.  But we don't try to optimize
   6198 	 when the symbol does not resolve locally.  */
   6199       if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
   6200 	return bfd_reloc_continue;
   6201       value = symbol + addend;
   6202       break;
   6203 
   6204     case R_MIPS_PJUMP:
   6205     case R_MIPS_GNU_VTINHERIT:
   6206     case R_MIPS_GNU_VTENTRY:
   6207       /* We don't do anything with these at present.  */
   6208       return bfd_reloc_continue;
   6209 
   6210     default:
   6211       /* An unrecognized relocation type.  */
   6212       return bfd_reloc_notsupported;
   6213     }
   6214 
   6215   /* Store the VALUE for our caller.  */
   6216   *valuep = value;
   6217   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
   6218 }
   6219 
   6220 /* Obtain the field relocated by RELOCATION.  */
   6221 
   6222 static bfd_vma
   6223 mips_elf_obtain_contents (reloc_howto_type *howto,
   6224 			  const Elf_Internal_Rela *relocation,
   6225 			  bfd *input_bfd, bfd_byte *contents)
   6226 {
   6227   bfd_vma x;
   6228   bfd_byte *location = contents + relocation->r_offset;
   6229 
   6230   /* Obtain the bytes.  */
   6231   x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
   6232 
   6233   return x;
   6234 }
   6235 
   6236 /* It has been determined that the result of the RELOCATION is the
   6237    VALUE.  Use HOWTO to place VALUE into the output file at the
   6238    appropriate position.  The SECTION is the section to which the
   6239    relocation applies.
   6240    CROSS_MODE_JUMP_P is true if the relocation field
   6241    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
   6242 
   6243    Returns FALSE if anything goes wrong.  */
   6244 
   6245 static bfd_boolean
   6246 mips_elf_perform_relocation (struct bfd_link_info *info,
   6247 			     reloc_howto_type *howto,
   6248 			     const Elf_Internal_Rela *relocation,
   6249 			     bfd_vma value, bfd *input_bfd,
   6250 			     asection *input_section, bfd_byte *contents,
   6251 			     bfd_boolean cross_mode_jump_p)
   6252 {
   6253   bfd_vma x;
   6254   bfd_byte *location;
   6255   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
   6256 
   6257   /* Figure out where the relocation is occurring.  */
   6258   location = contents + relocation->r_offset;
   6259 
   6260   _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
   6261 
   6262   /* Obtain the current value.  */
   6263   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
   6264 
   6265   /* Clear the field we are setting.  */
   6266   x &= ~howto->dst_mask;
   6267 
   6268   /* Set the field.  */
   6269   x |= (value & howto->dst_mask);
   6270 
   6271   /* If required, turn JAL into JALX.  */
   6272   if (cross_mode_jump_p && jal_reloc_p (r_type))
   6273     {
   6274       bfd_boolean ok;
   6275       bfd_vma opcode = x >> 26;
   6276       bfd_vma jalx_opcode;
   6277 
   6278       /* Check to see if the opcode is already JAL or JALX.  */
   6279       if (r_type == R_MIPS16_26)
   6280 	{
   6281 	  ok = ((opcode == 0x6) || (opcode == 0x7));
   6282 	  jalx_opcode = 0x7;
   6283 	}
   6284       else if (r_type == R_MICROMIPS_26_S1)
   6285 	{
   6286 	  ok = ((opcode == 0x3d) || (opcode == 0x3c));
   6287 	  jalx_opcode = 0x3c;
   6288 	}
   6289       else
   6290 	{
   6291 	  ok = ((opcode == 0x3) || (opcode == 0x1d));
   6292 	  jalx_opcode = 0x1d;
   6293 	}
   6294 
   6295       /* If the opcode is not JAL or JALX, there's a problem.  We cannot
   6296          convert J or JALS to JALX.  */
   6297       if (!ok)
   6298 	{
   6299 	  (*_bfd_error_handler)
   6300 	    (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
   6301 	     input_bfd,
   6302 	     input_section,
   6303 	     (unsigned long) relocation->r_offset);
   6304 	  bfd_set_error (bfd_error_bad_value);
   6305 	  return FALSE;
   6306 	}
   6307 
   6308       /* Make this the JALX opcode.  */
   6309       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
   6310     }
   6311 
   6312   /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
   6313      range.  */
   6314   if (!info->relocatable
   6315       && !cross_mode_jump_p
   6316       && ((JAL_TO_BAL_P (input_bfd)
   6317 	   && r_type == R_MIPS_26
   6318 	   && (x >> 26) == 0x3)		/* jal addr */
   6319 	  || (JALR_TO_BAL_P (input_bfd)
   6320 	      && r_type == R_MIPS_JALR
   6321 	      && x == 0x0320f809)	/* jalr t9 */
   6322 	  || (JR_TO_B_P (input_bfd)
   6323 	      && r_type == R_MIPS_JALR
   6324 	      && x == 0x03200008)))	/* jr t9 */
   6325     {
   6326       bfd_vma addr;
   6327       bfd_vma dest;
   6328       bfd_signed_vma off;
   6329 
   6330       addr = (input_section->output_section->vma
   6331 	      + input_section->output_offset
   6332 	      + relocation->r_offset
   6333 	      + 4);
   6334       if (r_type == R_MIPS_26)
   6335 	dest = (value << 2) | ((addr >> 28) << 28);
   6336       else
   6337 	dest = value;
   6338       off = dest - addr;
   6339       if (off <= 0x1ffff && off >= -0x20000)
   6340 	{
   6341 	  if (x == 0x03200008)	/* jr t9 */
   6342 	    x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff);   /* b addr */
   6343 	  else
   6344 	    x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
   6345 	}
   6346     }
   6347 
   6348   /* Put the value into the output.  */
   6349   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
   6350 
   6351   _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
   6352 			       location);
   6353 
   6354   return TRUE;
   6355 }
   6356 
   6357 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
   6359    is the original relocation, which is now being transformed into a
   6360    dynamic relocation.  The ADDENDP is adjusted if necessary; the
   6361    caller should store the result in place of the original addend.  */
   6362 
   6363 static bfd_boolean
   6364 mips_elf_create_dynamic_relocation (bfd *output_bfd,
   6365 				    struct bfd_link_info *info,
   6366 				    const Elf_Internal_Rela *rel,
   6367 				    struct mips_elf_link_hash_entry *h,
   6368 				    asection *sec, bfd_vma symbol,
   6369 				    bfd_vma *addendp, asection *input_section)
   6370 {
   6371   Elf_Internal_Rela outrel[3];
   6372   asection *sreloc;
   6373   bfd *dynobj;
   6374   int r_type;
   6375   long indx;
   6376   bfd_boolean defined_p;
   6377   struct mips_elf_link_hash_table *htab;
   6378 
   6379   htab = mips_elf_hash_table (info);
   6380   BFD_ASSERT (htab != NULL);
   6381 
   6382   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
   6383   dynobj = elf_hash_table (info)->dynobj;
   6384   sreloc = mips_elf_rel_dyn_section (info, FALSE);
   6385   BFD_ASSERT (sreloc != NULL);
   6386   BFD_ASSERT (sreloc->contents != NULL);
   6387   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
   6388 	      < sreloc->size);
   6389 
   6390   outrel[0].r_offset =
   6391     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
   6392   if (ABI_64_P (output_bfd))
   6393     {
   6394       outrel[1].r_offset =
   6395 	_bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
   6396       outrel[2].r_offset =
   6397 	_bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
   6398     }
   6399 
   6400   if (outrel[0].r_offset == MINUS_ONE)
   6401     /* The relocation field has been deleted.  */
   6402     return TRUE;
   6403 
   6404   if (outrel[0].r_offset == MINUS_TWO)
   6405     {
   6406       /* The relocation field has been converted into a relative value of
   6407 	 some sort.  Functions like _bfd_elf_write_section_eh_frame expect
   6408 	 the field to be fully relocated, so add in the symbol's value.  */
   6409       *addendp += symbol;
   6410       return TRUE;
   6411     }
   6412 
   6413   /* We must now calculate the dynamic symbol table index to use
   6414      in the relocation.  */
   6415   if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
   6416     {
   6417       BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
   6418       indx = h->root.dynindx;
   6419       if (SGI_COMPAT (output_bfd))
   6420 	defined_p = h->root.def_regular;
   6421       else
   6422 	/* ??? glibc's ld.so just adds the final GOT entry to the
   6423 	   relocation field.  It therefore treats relocs against
   6424 	   defined symbols in the same way as relocs against
   6425 	   undefined symbols.  */
   6426 	defined_p = FALSE;
   6427     }
   6428   else
   6429     {
   6430       if (sec != NULL && bfd_is_abs_section (sec))
   6431 	indx = 0;
   6432       else if (sec == NULL || sec->owner == NULL)
   6433 	{
   6434 	  bfd_set_error (bfd_error_bad_value);
   6435 	  return FALSE;
   6436 	}
   6437       else
   6438 	{
   6439 	  indx = elf_section_data (sec->output_section)->dynindx;
   6440 	  if (indx == 0)
   6441 	    {
   6442 	      asection *osec = htab->root.text_index_section;
   6443 	      indx = elf_section_data (osec)->dynindx;
   6444 	    }
   6445 	  if (indx == 0)
   6446 	    abort ();
   6447 	}
   6448 
   6449       /* Instead of generating a relocation using the section
   6450 	 symbol, we may as well make it a fully relative
   6451 	 relocation.  We want to avoid generating relocations to
   6452 	 local symbols because we used to generate them
   6453 	 incorrectly, without adding the original symbol value,
   6454 	 which is mandated by the ABI for section symbols.  In
   6455 	 order to give dynamic loaders and applications time to
   6456 	 phase out the incorrect use, we refrain from emitting
   6457 	 section-relative relocations.  It's not like they're
   6458 	 useful, after all.  This should be a bit more efficient
   6459 	 as well.  */
   6460       /* ??? Although this behavior is compatible with glibc's ld.so,
   6461 	 the ABI says that relocations against STN_UNDEF should have
   6462 	 a symbol value of 0.  Irix rld honors this, so relocations
   6463 	 against STN_UNDEF have no effect.  */
   6464       if (!SGI_COMPAT (output_bfd))
   6465 	indx = 0;
   6466       defined_p = TRUE;
   6467     }
   6468 
   6469   /* If the relocation was previously an absolute relocation and
   6470      this symbol will not be referred to by the relocation, we must
   6471      adjust it by the value we give it in the dynamic symbol table.
   6472      Otherwise leave the job up to the dynamic linker.  */
   6473   if (defined_p && r_type != R_MIPS_REL32)
   6474     *addendp += symbol;
   6475 
   6476   if (htab->is_vxworks)
   6477     /* VxWorks uses non-relative relocations for this.  */
   6478     outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
   6479   else
   6480     /* The relocation is always an REL32 relocation because we don't
   6481        know where the shared library will wind up at load-time.  */
   6482     outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
   6483 				   R_MIPS_REL32);
   6484 
   6485   /* For strict adherence to the ABI specification, we should
   6486      generate a R_MIPS_64 relocation record by itself before the
   6487      _REL32/_64 record as well, such that the addend is read in as
   6488      a 64-bit value (REL32 is a 32-bit relocation, after all).
   6489      However, since none of the existing ELF64 MIPS dynamic
   6490      loaders seems to care, we don't waste space with these
   6491      artificial relocations.  If this turns out to not be true,
   6492      mips_elf_allocate_dynamic_relocation() should be tweaked so
   6493      as to make room for a pair of dynamic relocations per
   6494      invocation if ABI_64_P, and here we should generate an
   6495      additional relocation record with R_MIPS_64 by itself for a
   6496      NULL symbol before this relocation record.  */
   6497   outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
   6498 				 ABI_64_P (output_bfd)
   6499 				 ? R_MIPS_64
   6500 				 : R_MIPS_NONE);
   6501   outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
   6502 
   6503   /* Adjust the output offset of the relocation to reference the
   6504      correct location in the output file.  */
   6505   outrel[0].r_offset += (input_section->output_section->vma
   6506 			 + input_section->output_offset);
   6507   outrel[1].r_offset += (input_section->output_section->vma
   6508 			 + input_section->output_offset);
   6509   outrel[2].r_offset += (input_section->output_section->vma
   6510 			 + input_section->output_offset);
   6511 
   6512   /* Put the relocation back out.  We have to use the special
   6513      relocation outputter in the 64-bit case since the 64-bit
   6514      relocation format is non-standard.  */
   6515   if (ABI_64_P (output_bfd))
   6516     {
   6517       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
   6518 	(output_bfd, &outrel[0],
   6519 	 (sreloc->contents
   6520 	  + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
   6521     }
   6522   else if (htab->is_vxworks)
   6523     {
   6524       /* VxWorks uses RELA rather than REL dynamic relocations.  */
   6525       outrel[0].r_addend = *addendp;
   6526       bfd_elf32_swap_reloca_out
   6527 	(output_bfd, &outrel[0],
   6528 	 (sreloc->contents
   6529 	  + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
   6530     }
   6531   else
   6532     bfd_elf32_swap_reloc_out
   6533       (output_bfd, &outrel[0],
   6534        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
   6535 
   6536   /* We've now added another relocation.  */
   6537   ++sreloc->reloc_count;
   6538 
   6539   /* Make sure the output section is writable.  The dynamic linker
   6540      will be writing to it.  */
   6541   elf_section_data (input_section->output_section)->this_hdr.sh_flags
   6542     |= SHF_WRITE;
   6543 
   6544   /* On IRIX5, make an entry of compact relocation info.  */
   6545   if (IRIX_COMPAT (output_bfd) == ict_irix5)
   6546     {
   6547       asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
   6548       bfd_byte *cr;
   6549 
   6550       if (scpt)
   6551 	{
   6552 	  Elf32_crinfo cptrel;
   6553 
   6554 	  mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
   6555 	  cptrel.vaddr = (rel->r_offset
   6556 			  + input_section->output_section->vma
   6557 			  + input_section->output_offset);
   6558 	  if (r_type == R_MIPS_REL32)
   6559 	    mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
   6560 	  else
   6561 	    mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
   6562 	  mips_elf_set_cr_dist2to (cptrel, 0);
   6563 	  cptrel.konst = *addendp;
   6564 
   6565 	  cr = (scpt->contents
   6566 		+ sizeof (Elf32_External_compact_rel));
   6567 	  mips_elf_set_cr_relvaddr (cptrel, 0);
   6568 	  bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
   6569 				     ((Elf32_External_crinfo *) cr
   6570 				      + scpt->reloc_count));
   6571 	  ++scpt->reloc_count;
   6572 	}
   6573     }
   6574 
   6575   /* If we've written this relocation for a readonly section,
   6576      we need to set DF_TEXTREL again, so that we do not delete the
   6577      DT_TEXTREL tag.  */
   6578   if (MIPS_ELF_READONLY_SECTION (input_section))
   6579     info->flags |= DF_TEXTREL;
   6580 
   6581   return TRUE;
   6582 }
   6583 
   6584 /* Return the MACH for a MIPS e_flags value.  */
   6586 
   6587 unsigned long
   6588 _bfd_elf_mips_mach (flagword flags)
   6589 {
   6590   switch (flags & EF_MIPS_MACH)
   6591     {
   6592     case E_MIPS_MACH_3900:
   6593       return bfd_mach_mips3900;
   6594 
   6595     case E_MIPS_MACH_4010:
   6596       return bfd_mach_mips4010;
   6597 
   6598     case E_MIPS_MACH_4100:
   6599       return bfd_mach_mips4100;
   6600 
   6601     case E_MIPS_MACH_4111:
   6602       return bfd_mach_mips4111;
   6603 
   6604     case E_MIPS_MACH_4120:
   6605       return bfd_mach_mips4120;
   6606 
   6607     case E_MIPS_MACH_4650:
   6608       return bfd_mach_mips4650;
   6609 
   6610     case E_MIPS_MACH_5400:
   6611       return bfd_mach_mips5400;
   6612 
   6613     case E_MIPS_MACH_5500:
   6614       return bfd_mach_mips5500;
   6615 
   6616     case E_MIPS_MACH_5900:
   6617       return bfd_mach_mips5900;
   6618 
   6619     case E_MIPS_MACH_9000:
   6620       return bfd_mach_mips9000;
   6621 
   6622     case E_MIPS_MACH_SB1:
   6623       return bfd_mach_mips_sb1;
   6624 
   6625     case E_MIPS_MACH_LS2E:
   6626       return bfd_mach_mips_loongson_2e;
   6627 
   6628     case E_MIPS_MACH_LS2F:
   6629       return bfd_mach_mips_loongson_2f;
   6630 
   6631     case E_MIPS_MACH_LS3A:
   6632       return bfd_mach_mips_loongson_3a;
   6633 
   6634     case E_MIPS_MACH_OCTEON3:
   6635       return bfd_mach_mips_octeon3;
   6636 
   6637     case E_MIPS_MACH_OCTEON2:
   6638       return bfd_mach_mips_octeon2;
   6639 
   6640     case E_MIPS_MACH_OCTEON:
   6641       return bfd_mach_mips_octeon;
   6642 
   6643     case E_MIPS_MACH_XLR:
   6644       return bfd_mach_mips_xlr;
   6645 
   6646     default:
   6647       switch (flags & EF_MIPS_ARCH)
   6648 	{
   6649 	default:
   6650 	case E_MIPS_ARCH_1:
   6651 	  return bfd_mach_mips3000;
   6652 
   6653 	case E_MIPS_ARCH_2:
   6654 	  return bfd_mach_mips6000;
   6655 
   6656 	case E_MIPS_ARCH_3:
   6657 	  return bfd_mach_mips4000;
   6658 
   6659 	case E_MIPS_ARCH_4:
   6660 	  return bfd_mach_mips8000;
   6661 
   6662 	case E_MIPS_ARCH_5:
   6663 	  return bfd_mach_mips5;
   6664 
   6665 	case E_MIPS_ARCH_32:
   6666 	  return bfd_mach_mipsisa32;
   6667 
   6668 	case E_MIPS_ARCH_64:
   6669 	  return bfd_mach_mipsisa64;
   6670 
   6671 	case E_MIPS_ARCH_32R2:
   6672 	  return bfd_mach_mipsisa32r2;
   6673 
   6674 	case E_MIPS_ARCH_64R2:
   6675 	  return bfd_mach_mipsisa64r2;
   6676 
   6677 	case E_MIPS_ARCH_32R6:
   6678 	  return bfd_mach_mipsisa32r6;
   6679 
   6680 	case E_MIPS_ARCH_64R6:
   6681 	  return bfd_mach_mipsisa64r6;
   6682 	}
   6683     }
   6684 
   6685   return 0;
   6686 }
   6687 
   6688 /* Return printable name for ABI.  */
   6689 
   6690 static INLINE char *
   6691 elf_mips_abi_name (bfd *abfd)
   6692 {
   6693   flagword flags;
   6694 
   6695   flags = elf_elfheader (abfd)->e_flags;
   6696   switch (flags & EF_MIPS_ABI)
   6697     {
   6698     case 0:
   6699       if (ABI_N32_P (abfd))
   6700 	return "N32";
   6701       else if (ABI_64_P (abfd))
   6702 	return "64";
   6703       else
   6704 	return "none";
   6705     case E_MIPS_ABI_O32:
   6706       return "O32";
   6707     case E_MIPS_ABI_O64:
   6708       return "O64";
   6709     case E_MIPS_ABI_EABI32:
   6710       return "EABI32";
   6711     case E_MIPS_ABI_EABI64:
   6712       return "EABI64";
   6713     default:
   6714       return "unknown abi";
   6715     }
   6716 }
   6717 
   6718 /* MIPS ELF uses two common sections.  One is the usual one, and the
   6720    other is for small objects.  All the small objects are kept
   6721    together, and then referenced via the gp pointer, which yields
   6722    faster assembler code.  This is what we use for the small common
   6723    section.  This approach is copied from ecoff.c.  */
   6724 static asection mips_elf_scom_section;
   6725 static asymbol mips_elf_scom_symbol;
   6726 static asymbol *mips_elf_scom_symbol_ptr;
   6727 
   6728 /* MIPS ELF also uses an acommon section, which represents an
   6729    allocated common symbol which may be overridden by a
   6730    definition in a shared library.  */
   6731 static asection mips_elf_acom_section;
   6732 static asymbol mips_elf_acom_symbol;
   6733 static asymbol *mips_elf_acom_symbol_ptr;
   6734 
   6735 /* This is used for both the 32-bit and the 64-bit ABI.  */
   6736 
   6737 void
   6738 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
   6739 {
   6740   elf_symbol_type *elfsym;
   6741 
   6742   /* Handle the special MIPS section numbers that a symbol may use.  */
   6743   elfsym = (elf_symbol_type *) asym;
   6744   switch (elfsym->internal_elf_sym.st_shndx)
   6745     {
   6746     case SHN_MIPS_ACOMMON:
   6747       /* This section is used in a dynamically linked executable file.
   6748 	 It is an allocated common section.  The dynamic linker can
   6749 	 either resolve these symbols to something in a shared
   6750 	 library, or it can just leave them here.  For our purposes,
   6751 	 we can consider these symbols to be in a new section.  */
   6752       if (mips_elf_acom_section.name == NULL)
   6753 	{
   6754 	  /* Initialize the acommon section.  */
   6755 	  mips_elf_acom_section.name = ".acommon";
   6756 	  mips_elf_acom_section.flags = SEC_ALLOC;
   6757 	  mips_elf_acom_section.output_section = &mips_elf_acom_section;
   6758 	  mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
   6759 	  mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
   6760 	  mips_elf_acom_symbol.name = ".acommon";
   6761 	  mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
   6762 	  mips_elf_acom_symbol.section = &mips_elf_acom_section;
   6763 	  mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
   6764 	}
   6765       asym->section = &mips_elf_acom_section;
   6766       break;
   6767 
   6768     case SHN_COMMON:
   6769       /* Common symbols less than the GP size are automatically
   6770 	 treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
   6771       if (asym->value > elf_gp_size (abfd)
   6772 	  || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
   6773 	  || IRIX_COMPAT (abfd) == ict_irix6)
   6774 	break;
   6775       /* Fall through.  */
   6776     case SHN_MIPS_SCOMMON:
   6777       if (mips_elf_scom_section.name == NULL)
   6778 	{
   6779 	  /* Initialize the small common section.  */
   6780 	  mips_elf_scom_section.name = ".scommon";
   6781 	  mips_elf_scom_section.flags = SEC_IS_COMMON;
   6782 	  mips_elf_scom_section.output_section = &mips_elf_scom_section;
   6783 	  mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
   6784 	  mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
   6785 	  mips_elf_scom_symbol.name = ".scommon";
   6786 	  mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
   6787 	  mips_elf_scom_symbol.section = &mips_elf_scom_section;
   6788 	  mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
   6789 	}
   6790       asym->section = &mips_elf_scom_section;
   6791       asym->value = elfsym->internal_elf_sym.st_size;
   6792       break;
   6793 
   6794     case SHN_MIPS_SUNDEFINED:
   6795       asym->section = bfd_und_section_ptr;
   6796       break;
   6797 
   6798     case SHN_MIPS_TEXT:
   6799       {
   6800 	asection *section = bfd_get_section_by_name (abfd, ".text");
   6801 
   6802 	if (section != NULL)
   6803 	  {
   6804 	    asym->section = section;
   6805 	    /* MIPS_TEXT is a bit special, the address is not an offset
   6806 	       to the base of the .text section.  So substract the section
   6807 	       base address to make it an offset.  */
   6808 	    asym->value -= section->vma;
   6809 	  }
   6810       }
   6811       break;
   6812 
   6813     case SHN_MIPS_DATA:
   6814       {
   6815 	asection *section = bfd_get_section_by_name (abfd, ".data");
   6816 
   6817 	if (section != NULL)
   6818 	  {
   6819 	    asym->section = section;
   6820 	    /* MIPS_DATA is a bit special, the address is not an offset
   6821 	       to the base of the .data section.  So substract the section
   6822 	       base address to make it an offset.  */
   6823 	    asym->value -= section->vma;
   6824 	  }
   6825       }
   6826       break;
   6827     }
   6828 
   6829   /* If this is an odd-valued function symbol, assume it's a MIPS16
   6830      or microMIPS one.  */
   6831   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
   6832       && (asym->value & 1) != 0)
   6833     {
   6834       asym->value--;
   6835       if (MICROMIPS_P (abfd))
   6836 	elfsym->internal_elf_sym.st_other
   6837 	  = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
   6838       else
   6839 	elfsym->internal_elf_sym.st_other
   6840 	  = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
   6841     }
   6842 }
   6843 
   6844 /* Implement elf_backend_eh_frame_address_size.  This differs from
   6846    the default in the way it handles EABI64.
   6847 
   6848    EABI64 was originally specified as an LP64 ABI, and that is what
   6849    -mabi=eabi normally gives on a 64-bit target.  However, gcc has
   6850    historically accepted the combination of -mabi=eabi and -mlong32,
   6851    and this ILP32 variation has become semi-official over time.
   6852    Both forms use elf32 and have pointer-sized FDE addresses.
   6853 
   6854    If an EABI object was generated by GCC 4.0 or above, it will have
   6855    an empty .gcc_compiled_longXX section, where XX is the size of longs
   6856    in bits.  Unfortunately, ILP32 objects generated by earlier compilers
   6857    have no special marking to distinguish them from LP64 objects.
   6858 
   6859    We don't want users of the official LP64 ABI to be punished for the
   6860    existence of the ILP32 variant, but at the same time, we don't want
   6861    to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
   6862    We therefore take the following approach:
   6863 
   6864       - If ABFD contains a .gcc_compiled_longXX section, use it to
   6865         determine the pointer size.
   6866 
   6867       - Otherwise check the type of the first relocation.  Assume that
   6868         the LP64 ABI is being used if the relocation is of type R_MIPS_64.
   6869 
   6870       - Otherwise punt.
   6871 
   6872    The second check is enough to detect LP64 objects generated by pre-4.0
   6873    compilers because, in the kind of output generated by those compilers,
   6874    the first relocation will be associated with either a CIE personality
   6875    routine or an FDE start address.  Furthermore, the compilers never
   6876    used a special (non-pointer) encoding for this ABI.
   6877 
   6878    Checking the relocation type should also be safe because there is no
   6879    reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
   6880    did so.  */
   6881 
   6882 unsigned int
   6883 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
   6884 {
   6885   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
   6886     return 8;
   6887   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
   6888     {
   6889       bfd_boolean long32_p, long64_p;
   6890 
   6891       long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
   6892       long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
   6893       if (long32_p && long64_p)
   6894 	return 0;
   6895       if (long32_p)
   6896 	return 4;
   6897       if (long64_p)
   6898 	return 8;
   6899 
   6900       if (sec->reloc_count > 0
   6901 	  && elf_section_data (sec)->relocs != NULL
   6902 	  && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
   6903 	      == R_MIPS_64))
   6904 	return 8;
   6905 
   6906       return 0;
   6907     }
   6908   return 4;
   6909 }
   6910 
   6911 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
   6913    relocations against two unnamed section symbols to resolve to the
   6914    same address.  For example, if we have code like:
   6915 
   6916 	lw	$4,%got_disp(.data)($gp)
   6917 	lw	$25,%got_disp(.text)($gp)
   6918 	jalr	$25
   6919 
   6920    then the linker will resolve both relocations to .data and the program
   6921    will jump there rather than to .text.
   6922 
   6923    We can work around this problem by giving names to local section symbols.
   6924    This is also what the MIPSpro tools do.  */
   6925 
   6926 bfd_boolean
   6927 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
   6928 {
   6929   return SGI_COMPAT (abfd);
   6930 }
   6931 
   6932 /* Work over a section just before writing it out.  This routine is
   6934    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
   6935    sections that need the SHF_MIPS_GPREL flag by name; there has to be
   6936    a better way.  */
   6937 
   6938 bfd_boolean
   6939 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
   6940 {
   6941   if (hdr->sh_type == SHT_MIPS_REGINFO
   6942       && hdr->sh_size > 0)
   6943     {
   6944       bfd_byte buf[4];
   6945 
   6946       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
   6947       BFD_ASSERT (hdr->contents == NULL);
   6948 
   6949       if (bfd_seek (abfd,
   6950 		    hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
   6951 		    SEEK_SET) != 0)
   6952 	return FALSE;
   6953       H_PUT_32 (abfd, elf_gp (abfd), buf);
   6954       if (bfd_bwrite (buf, 4, abfd) != 4)
   6955 	return FALSE;
   6956     }
   6957 
   6958   if (hdr->sh_type == SHT_MIPS_OPTIONS
   6959       && hdr->bfd_section != NULL
   6960       && mips_elf_section_data (hdr->bfd_section) != NULL
   6961       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
   6962     {
   6963       bfd_byte *contents, *l, *lend;
   6964 
   6965       /* We stored the section contents in the tdata field in the
   6966 	 set_section_contents routine.  We save the section contents
   6967 	 so that we don't have to read them again.
   6968 	 At this point we know that elf_gp is set, so we can look
   6969 	 through the section contents to see if there is an
   6970 	 ODK_REGINFO structure.  */
   6971 
   6972       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
   6973       l = contents;
   6974       lend = contents + hdr->sh_size;
   6975       while (l + sizeof (Elf_External_Options) <= lend)
   6976 	{
   6977 	  Elf_Internal_Options intopt;
   6978 
   6979 	  bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
   6980 					&intopt);
   6981 	  if (intopt.size < sizeof (Elf_External_Options))
   6982 	    {
   6983 	      (*_bfd_error_handler)
   6984 		(_("%B: Warning: bad `%s' option size %u smaller than its header"),
   6985 		abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
   6986 	      break;
   6987 	    }
   6988 	  if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
   6989 	    {
   6990 	      bfd_byte buf[8];
   6991 
   6992 	      if (bfd_seek (abfd,
   6993 			    (hdr->sh_offset
   6994 			     + (l - contents)
   6995 			     + sizeof (Elf_External_Options)
   6996 			     + (sizeof (Elf64_External_RegInfo) - 8)),
   6997 			     SEEK_SET) != 0)
   6998 		return FALSE;
   6999 	      H_PUT_64 (abfd, elf_gp (abfd), buf);
   7000 	      if (bfd_bwrite (buf, 8, abfd) != 8)
   7001 		return FALSE;
   7002 	    }
   7003 	  else if (intopt.kind == ODK_REGINFO)
   7004 	    {
   7005 	      bfd_byte buf[4];
   7006 
   7007 	      if (bfd_seek (abfd,
   7008 			    (hdr->sh_offset
   7009 			     + (l - contents)
   7010 			     + sizeof (Elf_External_Options)
   7011 			     + (sizeof (Elf32_External_RegInfo) - 4)),
   7012 			    SEEK_SET) != 0)
   7013 		return FALSE;
   7014 	      H_PUT_32 (abfd, elf_gp (abfd), buf);
   7015 	      if (bfd_bwrite (buf, 4, abfd) != 4)
   7016 		return FALSE;
   7017 	    }
   7018 	  l += intopt.size;
   7019 	}
   7020     }
   7021 
   7022   if (hdr->bfd_section != NULL)
   7023     {
   7024       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
   7025 
   7026       /* .sbss is not handled specially here because the GNU/Linux
   7027 	 prelinker can convert .sbss from NOBITS to PROGBITS and
   7028 	 changing it back to NOBITS breaks the binary.  The entry in
   7029 	 _bfd_mips_elf_special_sections will ensure the correct flags
   7030 	 are set on .sbss if BFD creates it without reading it from an
   7031 	 input file, and without special handling here the flags set
   7032 	 on it in an input file will be followed.  */
   7033       if (strcmp (name, ".sdata") == 0
   7034 	  || strcmp (name, ".lit8") == 0
   7035 	  || strcmp (name, ".lit4") == 0)
   7036 	hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
   7037       else if (strcmp (name, ".srdata") == 0)
   7038 	hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
   7039       else if (strcmp (name, ".compact_rel") == 0)
   7040 	hdr->sh_flags = 0;
   7041       else if (strcmp (name, ".rtproc") == 0)
   7042 	{
   7043 	  if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
   7044 	    {
   7045 	      unsigned int adjust;
   7046 
   7047 	      adjust = hdr->sh_size % hdr->sh_addralign;
   7048 	      if (adjust != 0)
   7049 		hdr->sh_size += hdr->sh_addralign - adjust;
   7050 	    }
   7051 	}
   7052     }
   7053 
   7054   return TRUE;
   7055 }
   7056 
   7057 /* Handle a MIPS specific section when reading an object file.  This
   7058    is called when elfcode.h finds a section with an unknown type.
   7059    This routine supports both the 32-bit and 64-bit ELF ABI.
   7060 
   7061    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
   7062    how to.  */
   7063 
   7064 bfd_boolean
   7065 _bfd_mips_elf_section_from_shdr (bfd *abfd,
   7066 				 Elf_Internal_Shdr *hdr,
   7067 				 const char *name,
   7068 				 int shindex)
   7069 {
   7070   flagword flags = 0;
   7071 
   7072   /* There ought to be a place to keep ELF backend specific flags, but
   7073      at the moment there isn't one.  We just keep track of the
   7074      sections by their name, instead.  Fortunately, the ABI gives
   7075      suggested names for all the MIPS specific sections, so we will
   7076      probably get away with this.  */
   7077   switch (hdr->sh_type)
   7078     {
   7079     case SHT_MIPS_LIBLIST:
   7080       if (strcmp (name, ".liblist") != 0)
   7081 	return FALSE;
   7082       break;
   7083     case SHT_MIPS_MSYM:
   7084       if (strcmp (name, ".msym") != 0)
   7085 	return FALSE;
   7086       break;
   7087     case SHT_MIPS_CONFLICT:
   7088       if (strcmp (name, ".conflict") != 0)
   7089 	return FALSE;
   7090       break;
   7091     case SHT_MIPS_GPTAB:
   7092       if (! CONST_STRNEQ (name, ".gptab."))
   7093 	return FALSE;
   7094       break;
   7095     case SHT_MIPS_UCODE:
   7096       if (strcmp (name, ".ucode") != 0)
   7097 	return FALSE;
   7098       break;
   7099     case SHT_MIPS_DEBUG:
   7100       if (strcmp (name, ".mdebug") != 0)
   7101 	return FALSE;
   7102       flags = SEC_DEBUGGING;
   7103       break;
   7104     case SHT_MIPS_REGINFO:
   7105       if (strcmp (name, ".reginfo") != 0
   7106 	  || hdr->sh_size != sizeof (Elf32_External_RegInfo))
   7107 	return FALSE;
   7108       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
   7109       break;
   7110     case SHT_MIPS_IFACE:
   7111       if (strcmp (name, ".MIPS.interfaces") != 0)
   7112 	return FALSE;
   7113       break;
   7114     case SHT_MIPS_CONTENT:
   7115       if (! CONST_STRNEQ (name, ".MIPS.content"))
   7116 	return FALSE;
   7117       break;
   7118     case SHT_MIPS_OPTIONS:
   7119       if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
   7120 	return FALSE;
   7121       break;
   7122     case SHT_MIPS_ABIFLAGS:
   7123       if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name))
   7124 	return FALSE;
   7125       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
   7126       break;
   7127     case SHT_MIPS_DWARF:
   7128       if (! CONST_STRNEQ (name, ".debug_")
   7129           && ! CONST_STRNEQ (name, ".zdebug_"))
   7130 	return FALSE;
   7131       break;
   7132     case SHT_MIPS_SYMBOL_LIB:
   7133       if (strcmp (name, ".MIPS.symlib") != 0)
   7134 	return FALSE;
   7135       break;
   7136     case SHT_MIPS_EVENTS:
   7137       if (! CONST_STRNEQ (name, ".MIPS.events")
   7138 	  && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
   7139 	return FALSE;
   7140       break;
   7141     default:
   7142       break;
   7143     }
   7144 
   7145   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
   7146     return FALSE;
   7147 
   7148   if (flags)
   7149     {
   7150       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
   7151 				   (bfd_get_section_flags (abfd,
   7152 							   hdr->bfd_section)
   7153 				    | flags)))
   7154 	return FALSE;
   7155     }
   7156 
   7157   if (hdr->sh_type == SHT_MIPS_ABIFLAGS)
   7158     {
   7159       Elf_External_ABIFlags_v0 ext;
   7160 
   7161       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
   7162 				      &ext, 0, sizeof ext))
   7163 	return FALSE;
   7164       bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext,
   7165 					&mips_elf_tdata (abfd)->abiflags);
   7166       if (mips_elf_tdata (abfd)->abiflags.version != 0)
   7167 	return FALSE;
   7168       mips_elf_tdata (abfd)->abiflags_valid = TRUE;
   7169     }
   7170 
   7171   /* FIXME: We should record sh_info for a .gptab section.  */
   7172 
   7173   /* For a .reginfo section, set the gp value in the tdata information
   7174      from the contents of this section.  We need the gp value while
   7175      processing relocs, so we just get it now.  The .reginfo section
   7176      is not used in the 64-bit MIPS ELF ABI.  */
   7177   if (hdr->sh_type == SHT_MIPS_REGINFO)
   7178     {
   7179       Elf32_External_RegInfo ext;
   7180       Elf32_RegInfo s;
   7181 
   7182       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
   7183 				      &ext, 0, sizeof ext))
   7184 	return FALSE;
   7185       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
   7186       elf_gp (abfd) = s.ri_gp_value;
   7187     }
   7188 
   7189   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
   7190      set the gp value based on what we find.  We may see both
   7191      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
   7192      they should agree.  */
   7193   if (hdr->sh_type == SHT_MIPS_OPTIONS)
   7194     {
   7195       bfd_byte *contents, *l, *lend;
   7196 
   7197       contents = bfd_malloc (hdr->sh_size);
   7198       if (contents == NULL)
   7199 	return FALSE;
   7200       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
   7201 				      0, hdr->sh_size))
   7202 	{
   7203 	  free (contents);
   7204 	  return FALSE;
   7205 	}
   7206       l = contents;
   7207       lend = contents + hdr->sh_size;
   7208       while (l + sizeof (Elf_External_Options) <= lend)
   7209 	{
   7210 	  Elf_Internal_Options intopt;
   7211 
   7212 	  bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
   7213 					&intopt);
   7214 	  if (intopt.size < sizeof (Elf_External_Options))
   7215 	    {
   7216 	      (*_bfd_error_handler)
   7217 		(_("%B: Warning: bad `%s' option size %u smaller than its header"),
   7218 		abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
   7219 	      break;
   7220 	    }
   7221 	  if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
   7222 	    {
   7223 	      Elf64_Internal_RegInfo intreg;
   7224 
   7225 	      bfd_mips_elf64_swap_reginfo_in
   7226 		(abfd,
   7227 		 ((Elf64_External_RegInfo *)
   7228 		  (l + sizeof (Elf_External_Options))),
   7229 		 &intreg);
   7230 	      elf_gp (abfd) = intreg.ri_gp_value;
   7231 	    }
   7232 	  else if (intopt.kind == ODK_REGINFO)
   7233 	    {
   7234 	      Elf32_RegInfo intreg;
   7235 
   7236 	      bfd_mips_elf32_swap_reginfo_in
   7237 		(abfd,
   7238 		 ((Elf32_External_RegInfo *)
   7239 		  (l + sizeof (Elf_External_Options))),
   7240 		 &intreg);
   7241 	      elf_gp (abfd) = intreg.ri_gp_value;
   7242 	    }
   7243 	  l += intopt.size;
   7244 	}
   7245       free (contents);
   7246     }
   7247 
   7248   return TRUE;
   7249 }
   7250 
   7251 /* Set the correct type for a MIPS ELF section.  We do this by the
   7252    section name, which is a hack, but ought to work.  This routine is
   7253    used by both the 32-bit and the 64-bit ABI.  */
   7254 
   7255 bfd_boolean
   7256 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
   7257 {
   7258   const char *name = bfd_get_section_name (abfd, sec);
   7259 
   7260   if (strcmp (name, ".liblist") == 0)
   7261     {
   7262       hdr->sh_type = SHT_MIPS_LIBLIST;
   7263       hdr->sh_info = sec->size / sizeof (Elf32_Lib);
   7264       /* The sh_link field is set in final_write_processing.  */
   7265     }
   7266   else if (strcmp (name, ".conflict") == 0)
   7267     hdr->sh_type = SHT_MIPS_CONFLICT;
   7268   else if (CONST_STRNEQ (name, ".gptab."))
   7269     {
   7270       hdr->sh_type = SHT_MIPS_GPTAB;
   7271       hdr->sh_entsize = sizeof (Elf32_External_gptab);
   7272       /* The sh_info field is set in final_write_processing.  */
   7273     }
   7274   else if (strcmp (name, ".ucode") == 0)
   7275     hdr->sh_type = SHT_MIPS_UCODE;
   7276   else if (strcmp (name, ".mdebug") == 0)
   7277     {
   7278       hdr->sh_type = SHT_MIPS_DEBUG;
   7279       /* In a shared object on IRIX 5.3, the .mdebug section has an
   7280          entsize of 0.  FIXME: Does this matter?  */
   7281       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
   7282 	hdr->sh_entsize = 0;
   7283       else
   7284 	hdr->sh_entsize = 1;
   7285     }
   7286   else if (strcmp (name, ".reginfo") == 0)
   7287     {
   7288       hdr->sh_type = SHT_MIPS_REGINFO;
   7289       /* In a shared object on IRIX 5.3, the .reginfo section has an
   7290          entsize of 0x18.  FIXME: Does this matter?  */
   7291       if (SGI_COMPAT (abfd))
   7292 	{
   7293 	  if ((abfd->flags & DYNAMIC) != 0)
   7294 	    hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
   7295 	  else
   7296 	    hdr->sh_entsize = 1;
   7297 	}
   7298       else
   7299 	hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
   7300     }
   7301   else if (SGI_COMPAT (abfd)
   7302 	   && (strcmp (name, ".hash") == 0
   7303 	       || strcmp (name, ".dynamic") == 0
   7304 	       || strcmp (name, ".dynstr") == 0))
   7305     {
   7306       if (SGI_COMPAT (abfd))
   7307 	hdr->sh_entsize = 0;
   7308 #if 0
   7309       /* This isn't how the IRIX6 linker behaves.  */
   7310       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
   7311 #endif
   7312     }
   7313   else if (strcmp (name, ".got") == 0
   7314 	   || strcmp (name, ".srdata") == 0
   7315 	   || strcmp (name, ".sdata") == 0
   7316 	   || strcmp (name, ".sbss") == 0
   7317 	   || strcmp (name, ".lit4") == 0
   7318 	   || strcmp (name, ".lit8") == 0)
   7319     hdr->sh_flags |= SHF_MIPS_GPREL;
   7320   else if (strcmp (name, ".MIPS.interfaces") == 0)
   7321     {
   7322       hdr->sh_type = SHT_MIPS_IFACE;
   7323       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
   7324     }
   7325   else if (CONST_STRNEQ (name, ".MIPS.content"))
   7326     {
   7327       hdr->sh_type = SHT_MIPS_CONTENT;
   7328       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
   7329       /* The sh_info field is set in final_write_processing.  */
   7330     }
   7331   else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
   7332     {
   7333       hdr->sh_type = SHT_MIPS_OPTIONS;
   7334       hdr->sh_entsize = 1;
   7335       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
   7336     }
   7337   else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
   7338     {
   7339       hdr->sh_type = SHT_MIPS_ABIFLAGS;
   7340       hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
   7341     }
   7342   else if (CONST_STRNEQ (name, ".debug_")
   7343            || CONST_STRNEQ (name, ".zdebug_"))
   7344     {
   7345       hdr->sh_type = SHT_MIPS_DWARF;
   7346 
   7347       /* Irix facilities such as libexc expect a single .debug_frame
   7348 	 per executable, the system ones have NOSTRIP set and the linker
   7349 	 doesn't merge sections with different flags so ...  */
   7350       if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
   7351 	hdr->sh_flags |= SHF_MIPS_NOSTRIP;
   7352     }
   7353   else if (strcmp (name, ".MIPS.symlib") == 0)
   7354     {
   7355       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
   7356       /* The sh_link and sh_info fields are set in
   7357          final_write_processing.  */
   7358     }
   7359   else if (CONST_STRNEQ (name, ".MIPS.events")
   7360 	   || CONST_STRNEQ (name, ".MIPS.post_rel"))
   7361     {
   7362       hdr->sh_type = SHT_MIPS_EVENTS;
   7363       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
   7364       /* The sh_link field is set in final_write_processing.  */
   7365     }
   7366   else if (strcmp (name, ".msym") == 0)
   7367     {
   7368       hdr->sh_type = SHT_MIPS_MSYM;
   7369       hdr->sh_flags |= SHF_ALLOC;
   7370       hdr->sh_entsize = 8;
   7371     }
   7372 
   7373   /* The generic elf_fake_sections will set up REL_HDR using the default
   7374    kind of relocations.  We used to set up a second header for the
   7375    non-default kind of relocations here, but only NewABI would use
   7376    these, and the IRIX ld doesn't like resulting empty RELA sections.
   7377    Thus we create those header only on demand now.  */
   7378 
   7379   return TRUE;
   7380 }
   7381 
   7382 /* Given a BFD section, try to locate the corresponding ELF section
   7383    index.  This is used by both the 32-bit and the 64-bit ABI.
   7384    Actually, it's not clear to me that the 64-bit ABI supports these,
   7385    but for non-PIC objects we will certainly want support for at least
   7386    the .scommon section.  */
   7387 
   7388 bfd_boolean
   7389 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
   7390 					asection *sec, int *retval)
   7391 {
   7392   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
   7393     {
   7394       *retval = SHN_MIPS_SCOMMON;
   7395       return TRUE;
   7396     }
   7397   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
   7398     {
   7399       *retval = SHN_MIPS_ACOMMON;
   7400       return TRUE;
   7401     }
   7402   return FALSE;
   7403 }
   7404 
   7405 /* Hook called by the linker routine which adds symbols from an object
   7407    file.  We must handle the special MIPS section numbers here.  */
   7408 
   7409 bfd_boolean
   7410 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
   7411 			       Elf_Internal_Sym *sym, const char **namep,
   7412 			       flagword *flagsp ATTRIBUTE_UNUSED,
   7413 			       asection **secp, bfd_vma *valp)
   7414 {
   7415   if (SGI_COMPAT (abfd)
   7416       && (abfd->flags & DYNAMIC) != 0
   7417       && strcmp (*namep, "_rld_new_interface") == 0)
   7418     {
   7419       /* Skip IRIX5 rld entry name.  */
   7420       *namep = NULL;
   7421       return TRUE;
   7422     }
   7423 
   7424   /* Shared objects may have a dynamic symbol '_gp_disp' defined as
   7425      a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
   7426      by setting a DT_NEEDED for the shared object.  Since _gp_disp is
   7427      a magic symbol resolved by the linker, we ignore this bogus definition
   7428      of _gp_disp.  New ABI objects do not suffer from this problem so this
   7429      is not done for them. */
   7430   if (!NEWABI_P(abfd)
   7431       && (sym->st_shndx == SHN_ABS)
   7432       && (strcmp (*namep, "_gp_disp") == 0))
   7433     {
   7434       *namep = NULL;
   7435       return TRUE;
   7436     }
   7437 
   7438   switch (sym->st_shndx)
   7439     {
   7440     case SHN_COMMON:
   7441       /* Common symbols less than the GP size are automatically
   7442 	 treated as SHN_MIPS_SCOMMON symbols.  */
   7443       if (sym->st_size > elf_gp_size (abfd)
   7444 	  || ELF_ST_TYPE (sym->st_info) == STT_TLS
   7445 	  || IRIX_COMPAT (abfd) == ict_irix6)
   7446 	break;
   7447       /* Fall through.  */
   7448     case SHN_MIPS_SCOMMON:
   7449       *secp = bfd_make_section_old_way (abfd, ".scommon");
   7450       (*secp)->flags |= SEC_IS_COMMON;
   7451       *valp = sym->st_size;
   7452       break;
   7453 
   7454     case SHN_MIPS_TEXT:
   7455       /* This section is used in a shared object.  */
   7456       if (mips_elf_tdata (abfd)->elf_text_section == NULL)
   7457 	{
   7458 	  asymbol *elf_text_symbol;
   7459 	  asection *elf_text_section;
   7460 	  bfd_size_type amt = sizeof (asection);
   7461 
   7462 	  elf_text_section = bfd_zalloc (abfd, amt);
   7463 	  if (elf_text_section == NULL)
   7464 	    return FALSE;
   7465 
   7466 	  amt = sizeof (asymbol);
   7467 	  elf_text_symbol = bfd_zalloc (abfd, amt);
   7468 	  if (elf_text_symbol == NULL)
   7469 	    return FALSE;
   7470 
   7471 	  /* Initialize the section.  */
   7472 
   7473 	  mips_elf_tdata (abfd)->elf_text_section = elf_text_section;
   7474 	  mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
   7475 
   7476 	  elf_text_section->symbol = elf_text_symbol;
   7477 	  elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol;
   7478 
   7479 	  elf_text_section->name = ".text";
   7480 	  elf_text_section->flags = SEC_NO_FLAGS;
   7481 	  elf_text_section->output_section = NULL;
   7482 	  elf_text_section->owner = abfd;
   7483 	  elf_text_symbol->name = ".text";
   7484 	  elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
   7485 	  elf_text_symbol->section = elf_text_section;
   7486 	}
   7487       /* This code used to do *secp = bfd_und_section_ptr if
   7488          info->shared.  I don't know why, and that doesn't make sense,
   7489          so I took it out.  */
   7490       *secp = mips_elf_tdata (abfd)->elf_text_section;
   7491       break;
   7492 
   7493     case SHN_MIPS_ACOMMON:
   7494       /* Fall through. XXX Can we treat this as allocated data?  */
   7495     case SHN_MIPS_DATA:
   7496       /* This section is used in a shared object.  */
   7497       if (mips_elf_tdata (abfd)->elf_data_section == NULL)
   7498 	{
   7499 	  asymbol *elf_data_symbol;
   7500 	  asection *elf_data_section;
   7501 	  bfd_size_type amt = sizeof (asection);
   7502 
   7503 	  elf_data_section = bfd_zalloc (abfd, amt);
   7504 	  if (elf_data_section == NULL)
   7505 	    return FALSE;
   7506 
   7507 	  amt = sizeof (asymbol);
   7508 	  elf_data_symbol = bfd_zalloc (abfd, amt);
   7509 	  if (elf_data_symbol == NULL)
   7510 	    return FALSE;
   7511 
   7512 	  /* Initialize the section.  */
   7513 
   7514 	  mips_elf_tdata (abfd)->elf_data_section = elf_data_section;
   7515 	  mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
   7516 
   7517 	  elf_data_section->symbol = elf_data_symbol;
   7518 	  elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol;
   7519 
   7520 	  elf_data_section->name = ".data";
   7521 	  elf_data_section->flags = SEC_NO_FLAGS;
   7522 	  elf_data_section->output_section = NULL;
   7523 	  elf_data_section->owner = abfd;
   7524 	  elf_data_symbol->name = ".data";
   7525 	  elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
   7526 	  elf_data_symbol->section = elf_data_section;
   7527 	}
   7528       /* This code used to do *secp = bfd_und_section_ptr if
   7529          info->shared.  I don't know why, and that doesn't make sense,
   7530          so I took it out.  */
   7531       *secp = mips_elf_tdata (abfd)->elf_data_section;
   7532       break;
   7533 
   7534     case SHN_MIPS_SUNDEFINED:
   7535       *secp = bfd_und_section_ptr;
   7536       break;
   7537     }
   7538 
   7539   if (SGI_COMPAT (abfd)
   7540       && ! info->shared
   7541       && info->output_bfd->xvec == abfd->xvec
   7542       && strcmp (*namep, "__rld_obj_head") == 0)
   7543     {
   7544       struct elf_link_hash_entry *h;
   7545       struct bfd_link_hash_entry *bh;
   7546 
   7547       /* Mark __rld_obj_head as dynamic.  */
   7548       bh = NULL;
   7549       if (! (_bfd_generic_link_add_one_symbol
   7550 	     (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
   7551 	      get_elf_backend_data (abfd)->collect, &bh)))
   7552 	return FALSE;
   7553 
   7554       h = (struct elf_link_hash_entry *) bh;
   7555       h->non_elf = 0;
   7556       h->def_regular = 1;
   7557       h->type = STT_OBJECT;
   7558 
   7559       if (! bfd_elf_link_record_dynamic_symbol (info, h))
   7560 	return FALSE;
   7561 
   7562       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
   7563       mips_elf_hash_table (info)->rld_symbol = h;
   7564     }
   7565 
   7566   /* If this is a mips16 text symbol, add 1 to the value to make it
   7567      odd.  This will cause something like .word SYM to come up with
   7568      the right value when it is loaded into the PC.  */
   7569   if (ELF_ST_IS_COMPRESSED (sym->st_other))
   7570     ++*valp;
   7571 
   7572   return TRUE;
   7573 }
   7574 
   7575 /* This hook function is called before the linker writes out a global
   7576    symbol.  We mark symbols as small common if appropriate.  This is
   7577    also where we undo the increment of the value for a mips16 symbol.  */
   7578 
   7579 int
   7580 _bfd_mips_elf_link_output_symbol_hook
   7581   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
   7582    const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
   7583    asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
   7584 {
   7585   /* If we see a common symbol, which implies a relocatable link, then
   7586      if a symbol was small common in an input file, mark it as small
   7587      common in the output file.  */
   7588   if (sym->st_shndx == SHN_COMMON
   7589       && strcmp (input_sec->name, ".scommon") == 0)
   7590     sym->st_shndx = SHN_MIPS_SCOMMON;
   7591 
   7592   if (ELF_ST_IS_COMPRESSED (sym->st_other))
   7593     sym->st_value &= ~1;
   7594 
   7595   return 1;
   7596 }
   7597 
   7598 /* Functions for the dynamic linker.  */
   7600 
   7601 /* Create dynamic sections when linking against a dynamic object.  */
   7602 
   7603 bfd_boolean
   7604 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   7605 {
   7606   struct elf_link_hash_entry *h;
   7607   struct bfd_link_hash_entry *bh;
   7608   flagword flags;
   7609   register asection *s;
   7610   const char * const *namep;
   7611   struct mips_elf_link_hash_table *htab;
   7612 
   7613   htab = mips_elf_hash_table (info);
   7614   BFD_ASSERT (htab != NULL);
   7615 
   7616   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
   7617 	   | SEC_LINKER_CREATED | SEC_READONLY);
   7618 
   7619   /* The psABI requires a read-only .dynamic section, but the VxWorks
   7620      EABI doesn't.  */
   7621   if (!htab->is_vxworks)
   7622     {
   7623       s = bfd_get_linker_section (abfd, ".dynamic");
   7624       if (s != NULL)
   7625 	{
   7626 	  if (! bfd_set_section_flags (abfd, s, flags))
   7627 	    return FALSE;
   7628 	}
   7629     }
   7630 
   7631   /* We need to create .got section.  */
   7632   if (!mips_elf_create_got_section (abfd, info))
   7633     return FALSE;
   7634 
   7635   if (! mips_elf_rel_dyn_section (info, TRUE))
   7636     return FALSE;
   7637 
   7638   /* Create .stub section.  */
   7639   s = bfd_make_section_anyway_with_flags (abfd,
   7640 					  MIPS_ELF_STUB_SECTION_NAME (abfd),
   7641 					  flags | SEC_CODE);
   7642   if (s == NULL
   7643       || ! bfd_set_section_alignment (abfd, s,
   7644 				      MIPS_ELF_LOG_FILE_ALIGN (abfd)))
   7645     return FALSE;
   7646   htab->sstubs = s;
   7647 
   7648   if (!mips_elf_hash_table (info)->use_rld_obj_head
   7649       && info->executable
   7650       && bfd_get_linker_section (abfd, ".rld_map") == NULL)
   7651     {
   7652       s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
   7653 					      flags &~ (flagword) SEC_READONLY);
   7654       if (s == NULL
   7655 	  || ! bfd_set_section_alignment (abfd, s,
   7656 					  MIPS_ELF_LOG_FILE_ALIGN (abfd)))
   7657 	return FALSE;
   7658     }
   7659 
   7660   /* On IRIX5, we adjust add some additional symbols and change the
   7661      alignments of several sections.  There is no ABI documentation
   7662      indicating that this is necessary on IRIX6, nor any evidence that
   7663      the linker takes such action.  */
   7664   if (IRIX_COMPAT (abfd) == ict_irix5)
   7665     {
   7666       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
   7667 	{
   7668 	  bh = NULL;
   7669 	  if (! (_bfd_generic_link_add_one_symbol
   7670 		 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
   7671 		  NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
   7672 	    return FALSE;
   7673 
   7674 	  h = (struct elf_link_hash_entry *) bh;
   7675 	  h->non_elf = 0;
   7676 	  h->def_regular = 1;
   7677 	  h->type = STT_SECTION;
   7678 
   7679 	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
   7680 	    return FALSE;
   7681 	}
   7682 
   7683       /* We need to create a .compact_rel section.  */
   7684       if (SGI_COMPAT (abfd))
   7685 	{
   7686 	  if (!mips_elf_create_compact_rel_section (abfd, info))
   7687 	    return FALSE;
   7688 	}
   7689 
   7690       /* Change alignments of some sections.  */
   7691       s = bfd_get_linker_section (abfd, ".hash");
   7692       if (s != NULL)
   7693 	(void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
   7694 
   7695       s = bfd_get_linker_section (abfd, ".dynsym");
   7696       if (s != NULL)
   7697 	(void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
   7698 
   7699       s = bfd_get_linker_section (abfd, ".dynstr");
   7700       if (s != NULL)
   7701 	(void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
   7702 
   7703       /* ??? */
   7704       s = bfd_get_section_by_name (abfd, ".reginfo");
   7705       if (s != NULL)
   7706 	(void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
   7707 
   7708       s = bfd_get_linker_section (abfd, ".dynamic");
   7709       if (s != NULL)
   7710 	(void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
   7711     }
   7712 
   7713   if (info->executable)
   7714     {
   7715       const char *name;
   7716 
   7717       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
   7718       bh = NULL;
   7719       if (!(_bfd_generic_link_add_one_symbol
   7720 	    (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
   7721 	     NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
   7722 	return FALSE;
   7723 
   7724       h = (struct elf_link_hash_entry *) bh;
   7725       h->non_elf = 0;
   7726       h->def_regular = 1;
   7727       h->type = STT_SECTION;
   7728 
   7729       if (! bfd_elf_link_record_dynamic_symbol (info, h))
   7730 	return FALSE;
   7731 
   7732       if (! mips_elf_hash_table (info)->use_rld_obj_head)
   7733 	{
   7734 	  /* __rld_map is a four byte word located in the .data section
   7735 	     and is filled in by the rtld to contain a pointer to
   7736 	     the _r_debug structure. Its symbol value will be set in
   7737 	     _bfd_mips_elf_finish_dynamic_symbol.  */
   7738 	  s = bfd_get_linker_section (abfd, ".rld_map");
   7739 	  BFD_ASSERT (s != NULL);
   7740 
   7741 	  name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
   7742 	  bh = NULL;
   7743 	  if (!(_bfd_generic_link_add_one_symbol
   7744 		(info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
   7745 		 get_elf_backend_data (abfd)->collect, &bh)))
   7746 	    return FALSE;
   7747 
   7748 	  h = (struct elf_link_hash_entry *) bh;
   7749 	  h->non_elf = 0;
   7750 	  h->def_regular = 1;
   7751 	  h->type = STT_OBJECT;
   7752 
   7753 	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
   7754 	    return FALSE;
   7755 	  mips_elf_hash_table (info)->rld_symbol = h;
   7756 	}
   7757     }
   7758 
   7759   /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
   7760      Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol.  */
   7761   if (!_bfd_elf_create_dynamic_sections (abfd, info))
   7762     return FALSE;
   7763 
   7764   /* Cache the sections created above.  */
   7765   htab->splt = bfd_get_linker_section (abfd, ".plt");
   7766   htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
   7767   if (htab->is_vxworks)
   7768     {
   7769       htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
   7770       htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
   7771     }
   7772   else
   7773     htab->srelplt = bfd_get_linker_section (abfd, ".rel.plt");
   7774   if (!htab->sdynbss
   7775       || (htab->is_vxworks && !htab->srelbss && !info->shared)
   7776       || !htab->srelplt
   7777       || !htab->splt)
   7778     abort ();
   7779 
   7780   /* Do the usual VxWorks handling.  */
   7781   if (htab->is_vxworks
   7782       && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
   7783     return FALSE;
   7784 
   7785   return TRUE;
   7786 }
   7787 
   7788 /* Return true if relocation REL against section SEC is a REL rather than
   7790    RELA relocation.  RELOCS is the first relocation in the section and
   7791    ABFD is the bfd that contains SEC.  */
   7792 
   7793 static bfd_boolean
   7794 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
   7795 			   const Elf_Internal_Rela *relocs,
   7796 			   const Elf_Internal_Rela *rel)
   7797 {
   7798   Elf_Internal_Shdr *rel_hdr;
   7799   const struct elf_backend_data *bed;
   7800 
   7801   /* To determine which flavor of relocation this is, we depend on the
   7802      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
   7803   rel_hdr = elf_section_data (sec)->rel.hdr;
   7804   if (rel_hdr == NULL)
   7805     return FALSE;
   7806   bed = get_elf_backend_data (abfd);
   7807   return ((size_t) (rel - relocs)
   7808 	  < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
   7809 }
   7810 
   7811 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
   7812    HOWTO is the relocation's howto and CONTENTS points to the contents
   7813    of the section that REL is against.  */
   7814 
   7815 static bfd_vma
   7816 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
   7817 			  reloc_howto_type *howto, bfd_byte *contents)
   7818 {
   7819   bfd_byte *location;
   7820   unsigned int r_type;
   7821   bfd_vma addend;
   7822 
   7823   r_type = ELF_R_TYPE (abfd, rel->r_info);
   7824   location = contents + rel->r_offset;
   7825 
   7826   /* Get the addend, which is stored in the input file.  */
   7827   _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
   7828   addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
   7829   _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
   7830 
   7831   return addend & howto->src_mask;
   7832 }
   7833 
   7834 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
   7835    and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
   7836    and update *ADDEND with the final addend.  Return true on success
   7837    or false if the LO16 could not be found.  RELEND is the exclusive
   7838    upper bound on the relocations for REL's section.  */
   7839 
   7840 static bfd_boolean
   7841 mips_elf_add_lo16_rel_addend (bfd *abfd,
   7842 			      const Elf_Internal_Rela *rel,
   7843 			      const Elf_Internal_Rela *relend,
   7844 			      bfd_byte *contents, bfd_vma *addend)
   7845 {
   7846   unsigned int r_type, lo16_type;
   7847   const Elf_Internal_Rela *lo16_relocation;
   7848   reloc_howto_type *lo16_howto;
   7849   bfd_vma l;
   7850 
   7851   r_type = ELF_R_TYPE (abfd, rel->r_info);
   7852   if (mips16_reloc_p (r_type))
   7853     lo16_type = R_MIPS16_LO16;
   7854   else if (micromips_reloc_p (r_type))
   7855     lo16_type = R_MICROMIPS_LO16;
   7856   else if (r_type == R_MIPS_PCHI16)
   7857     lo16_type = R_MIPS_PCLO16;
   7858   else
   7859     lo16_type = R_MIPS_LO16;
   7860 
   7861   /* The combined value is the sum of the HI16 addend, left-shifted by
   7862      sixteen bits, and the LO16 addend, sign extended.  (Usually, the
   7863      code does a `lui' of the HI16 value, and then an `addiu' of the
   7864      LO16 value.)
   7865 
   7866      Scan ahead to find a matching LO16 relocation.
   7867 
   7868      According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
   7869      be immediately following.  However, for the IRIX6 ABI, the next
   7870      relocation may be a composed relocation consisting of several
   7871      relocations for the same address.  In that case, the R_MIPS_LO16
   7872      relocation may occur as one of these.  We permit a similar
   7873      extension in general, as that is useful for GCC.
   7874 
   7875      In some cases GCC dead code elimination removes the LO16 but keeps
   7876      the corresponding HI16.  This is strictly speaking a violation of
   7877      the ABI but not immediately harmful.  */
   7878   lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
   7879   if (lo16_relocation == NULL)
   7880     return FALSE;
   7881 
   7882   /* Obtain the addend kept there.  */
   7883   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
   7884   l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
   7885 
   7886   l <<= lo16_howto->rightshift;
   7887   l = _bfd_mips_elf_sign_extend (l, 16);
   7888 
   7889   *addend <<= 16;
   7890   *addend += l;
   7891   return TRUE;
   7892 }
   7893 
   7894 /* Try to read the contents of section SEC in bfd ABFD.  Return true and
   7895    store the contents in *CONTENTS on success.  Assume that *CONTENTS
   7896    already holds the contents if it is nonull on entry.  */
   7897 
   7898 static bfd_boolean
   7899 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
   7900 {
   7901   if (*contents)
   7902     return TRUE;
   7903 
   7904   /* Get cached copy if it exists.  */
   7905   if (elf_section_data (sec)->this_hdr.contents != NULL)
   7906     {
   7907       *contents = elf_section_data (sec)->this_hdr.contents;
   7908       return TRUE;
   7909     }
   7910 
   7911   return bfd_malloc_and_get_section (abfd, sec, contents);
   7912 }
   7913 
   7914 /* Make a new PLT record to keep internal data.  */
   7915 
   7916 static struct plt_entry *
   7917 mips_elf_make_plt_record (bfd *abfd)
   7918 {
   7919   struct plt_entry *entry;
   7920 
   7921   entry = bfd_zalloc (abfd, sizeof (*entry));
   7922   if (entry == NULL)
   7923     return NULL;
   7924 
   7925   entry->stub_offset = MINUS_ONE;
   7926   entry->mips_offset = MINUS_ONE;
   7927   entry->comp_offset = MINUS_ONE;
   7928   entry->gotplt_index = MINUS_ONE;
   7929   return entry;
   7930 }
   7931 
   7932 /* Look through the relocs for a section during the first phase, and
   7933    allocate space in the global offset table and record the need for
   7934    standard MIPS and compressed procedure linkage table entries.  */
   7935 
   7936 bfd_boolean
   7937 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
   7938 			    asection *sec, const Elf_Internal_Rela *relocs)
   7939 {
   7940   const char *name;
   7941   bfd *dynobj;
   7942   Elf_Internal_Shdr *symtab_hdr;
   7943   struct elf_link_hash_entry **sym_hashes;
   7944   size_t extsymoff;
   7945   const Elf_Internal_Rela *rel;
   7946   const Elf_Internal_Rela *rel_end;
   7947   asection *sreloc;
   7948   const struct elf_backend_data *bed;
   7949   struct mips_elf_link_hash_table *htab;
   7950   bfd_byte *contents;
   7951   bfd_vma addend;
   7952   reloc_howto_type *howto;
   7953 
   7954   if (info->relocatable)
   7955     return TRUE;
   7956 
   7957   htab = mips_elf_hash_table (info);
   7958   BFD_ASSERT (htab != NULL);
   7959 
   7960   dynobj = elf_hash_table (info)->dynobj;
   7961   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   7962   sym_hashes = elf_sym_hashes (abfd);
   7963   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
   7964 
   7965   bed = get_elf_backend_data (abfd);
   7966   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
   7967 
   7968   /* Check for the mips16 stub sections.  */
   7969 
   7970   name = bfd_get_section_name (abfd, sec);
   7971   if (FN_STUB_P (name))
   7972     {
   7973       unsigned long r_symndx;
   7974 
   7975       /* Look at the relocation information to figure out which symbol
   7976          this is for.  */
   7977 
   7978       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
   7979       if (r_symndx == 0)
   7980 	{
   7981 	  (*_bfd_error_handler)
   7982 	    (_("%B: Warning: cannot determine the target function for"
   7983 	       " stub section `%s'"),
   7984 	     abfd, name);
   7985 	  bfd_set_error (bfd_error_bad_value);
   7986 	  return FALSE;
   7987 	}
   7988 
   7989       if (r_symndx < extsymoff
   7990 	  || sym_hashes[r_symndx - extsymoff] == NULL)
   7991 	{
   7992 	  asection *o;
   7993 
   7994 	  /* This stub is for a local symbol.  This stub will only be
   7995              needed if there is some relocation in this BFD, other
   7996              than a 16 bit function call, which refers to this symbol.  */
   7997 	  for (o = abfd->sections; o != NULL; o = o->next)
   7998 	    {
   7999 	      Elf_Internal_Rela *sec_relocs;
   8000 	      const Elf_Internal_Rela *r, *rend;
   8001 
   8002 	      /* We can ignore stub sections when looking for relocs.  */
   8003 	      if ((o->flags & SEC_RELOC) == 0
   8004 		  || o->reloc_count == 0
   8005 		  || section_allows_mips16_refs_p (o))
   8006 		continue;
   8007 
   8008 	      sec_relocs
   8009 		= _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
   8010 					     info->keep_memory);
   8011 	      if (sec_relocs == NULL)
   8012 		return FALSE;
   8013 
   8014 	      rend = sec_relocs + o->reloc_count;
   8015 	      for (r = sec_relocs; r < rend; r++)
   8016 		if (ELF_R_SYM (abfd, r->r_info) == r_symndx
   8017 		    && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
   8018 		  break;
   8019 
   8020 	      if (elf_section_data (o)->relocs != sec_relocs)
   8021 		free (sec_relocs);
   8022 
   8023 	      if (r < rend)
   8024 		break;
   8025 	    }
   8026 
   8027 	  if (o == NULL)
   8028 	    {
   8029 	      /* There is no non-call reloc for this stub, so we do
   8030                  not need it.  Since this function is called before
   8031                  the linker maps input sections to output sections, we
   8032                  can easily discard it by setting the SEC_EXCLUDE
   8033                  flag.  */
   8034 	      sec->flags |= SEC_EXCLUDE;
   8035 	      return TRUE;
   8036 	    }
   8037 
   8038 	  /* Record this stub in an array of local symbol stubs for
   8039              this BFD.  */
   8040 	  if (mips_elf_tdata (abfd)->local_stubs == NULL)
   8041 	    {
   8042 	      unsigned long symcount;
   8043 	      asection **n;
   8044 	      bfd_size_type amt;
   8045 
   8046 	      if (elf_bad_symtab (abfd))
   8047 		symcount = NUM_SHDR_ENTRIES (symtab_hdr);
   8048 	      else
   8049 		symcount = symtab_hdr->sh_info;
   8050 	      amt = symcount * sizeof (asection *);
   8051 	      n = bfd_zalloc (abfd, amt);
   8052 	      if (n == NULL)
   8053 		return FALSE;
   8054 	      mips_elf_tdata (abfd)->local_stubs = n;
   8055 	    }
   8056 
   8057 	  sec->flags |= SEC_KEEP;
   8058 	  mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec;
   8059 
   8060 	  /* We don't need to set mips16_stubs_seen in this case.
   8061              That flag is used to see whether we need to look through
   8062              the global symbol table for stubs.  We don't need to set
   8063              it here, because we just have a local stub.  */
   8064 	}
   8065       else
   8066 	{
   8067 	  struct mips_elf_link_hash_entry *h;
   8068 
   8069 	  h = ((struct mips_elf_link_hash_entry *)
   8070 	       sym_hashes[r_symndx - extsymoff]);
   8071 
   8072 	  while (h->root.root.type == bfd_link_hash_indirect
   8073 		 || h->root.root.type == bfd_link_hash_warning)
   8074 	    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
   8075 
   8076 	  /* H is the symbol this stub is for.  */
   8077 
   8078 	  /* If we already have an appropriate stub for this function, we
   8079 	     don't need another one, so we can discard this one.  Since
   8080 	     this function is called before the linker maps input sections
   8081 	     to output sections, we can easily discard it by setting the
   8082 	     SEC_EXCLUDE flag.  */
   8083 	  if (h->fn_stub != NULL)
   8084 	    {
   8085 	      sec->flags |= SEC_EXCLUDE;
   8086 	      return TRUE;
   8087 	    }
   8088 
   8089 	  sec->flags |= SEC_KEEP;
   8090 	  h->fn_stub = sec;
   8091 	  mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
   8092 	}
   8093     }
   8094   else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
   8095     {
   8096       unsigned long r_symndx;
   8097       struct mips_elf_link_hash_entry *h;
   8098       asection **loc;
   8099 
   8100       /* Look at the relocation information to figure out which symbol
   8101          this is for.  */
   8102 
   8103       r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
   8104       if (r_symndx == 0)
   8105 	{
   8106 	  (*_bfd_error_handler)
   8107 	    (_("%B: Warning: cannot determine the target function for"
   8108 	       " stub section `%s'"),
   8109 	     abfd, name);
   8110 	  bfd_set_error (bfd_error_bad_value);
   8111 	  return FALSE;
   8112 	}
   8113 
   8114       if (r_symndx < extsymoff
   8115 	  || sym_hashes[r_symndx - extsymoff] == NULL)
   8116 	{
   8117 	  asection *o;
   8118 
   8119 	  /* This stub is for a local symbol.  This stub will only be
   8120              needed if there is some relocation (R_MIPS16_26) in this BFD
   8121              that refers to this symbol.  */
   8122 	  for (o = abfd->sections; o != NULL; o = o->next)
   8123 	    {
   8124 	      Elf_Internal_Rela *sec_relocs;
   8125 	      const Elf_Internal_Rela *r, *rend;
   8126 
   8127 	      /* We can ignore stub sections when looking for relocs.  */
   8128 	      if ((o->flags & SEC_RELOC) == 0
   8129 		  || o->reloc_count == 0
   8130 		  || section_allows_mips16_refs_p (o))
   8131 		continue;
   8132 
   8133 	      sec_relocs
   8134 		= _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
   8135 					     info->keep_memory);
   8136 	      if (sec_relocs == NULL)
   8137 		return FALSE;
   8138 
   8139 	      rend = sec_relocs + o->reloc_count;
   8140 	      for (r = sec_relocs; r < rend; r++)
   8141 		if (ELF_R_SYM (abfd, r->r_info) == r_symndx
   8142 		    && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
   8143 		    break;
   8144 
   8145 	      if (elf_section_data (o)->relocs != sec_relocs)
   8146 		free (sec_relocs);
   8147 
   8148 	      if (r < rend)
   8149 		break;
   8150 	    }
   8151 
   8152 	  if (o == NULL)
   8153 	    {
   8154 	      /* There is no non-call reloc for this stub, so we do
   8155                  not need it.  Since this function is called before
   8156                  the linker maps input sections to output sections, we
   8157                  can easily discard it by setting the SEC_EXCLUDE
   8158                  flag.  */
   8159 	      sec->flags |= SEC_EXCLUDE;
   8160 	      return TRUE;
   8161 	    }
   8162 
   8163 	  /* Record this stub in an array of local symbol call_stubs for
   8164              this BFD.  */
   8165 	  if (mips_elf_tdata (abfd)->local_call_stubs == NULL)
   8166 	    {
   8167 	      unsigned long symcount;
   8168 	      asection **n;
   8169 	      bfd_size_type amt;
   8170 
   8171 	      if (elf_bad_symtab (abfd))
   8172 		symcount = NUM_SHDR_ENTRIES (symtab_hdr);
   8173 	      else
   8174 		symcount = symtab_hdr->sh_info;
   8175 	      amt = symcount * sizeof (asection *);
   8176 	      n = bfd_zalloc (abfd, amt);
   8177 	      if (n == NULL)
   8178 		return FALSE;
   8179 	      mips_elf_tdata (abfd)->local_call_stubs = n;
   8180 	    }
   8181 
   8182 	  sec->flags |= SEC_KEEP;
   8183 	  mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
   8184 
   8185 	  /* We don't need to set mips16_stubs_seen in this case.
   8186              That flag is used to see whether we need to look through
   8187              the global symbol table for stubs.  We don't need to set
   8188              it here, because we just have a local stub.  */
   8189 	}
   8190       else
   8191 	{
   8192 	  h = ((struct mips_elf_link_hash_entry *)
   8193 	       sym_hashes[r_symndx - extsymoff]);
   8194 
   8195 	  /* H is the symbol this stub is for.  */
   8196 
   8197 	  if (CALL_FP_STUB_P (name))
   8198 	    loc = &h->call_fp_stub;
   8199 	  else
   8200 	    loc = &h->call_stub;
   8201 
   8202 	  /* If we already have an appropriate stub for this function, we
   8203 	     don't need another one, so we can discard this one.  Since
   8204 	     this function is called before the linker maps input sections
   8205 	     to output sections, we can easily discard it by setting the
   8206 	     SEC_EXCLUDE flag.  */
   8207 	  if (*loc != NULL)
   8208 	    {
   8209 	      sec->flags |= SEC_EXCLUDE;
   8210 	      return TRUE;
   8211 	    }
   8212 
   8213 	  sec->flags |= SEC_KEEP;
   8214 	  *loc = sec;
   8215 	  mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
   8216 	}
   8217     }
   8218 
   8219   sreloc = NULL;
   8220   contents = NULL;
   8221   for (rel = relocs; rel < rel_end; ++rel)
   8222     {
   8223       unsigned long r_symndx;
   8224       unsigned int r_type;
   8225       struct elf_link_hash_entry *h;
   8226       bfd_boolean can_make_dynamic_p;
   8227       bfd_boolean call_reloc_p;
   8228       bfd_boolean constrain_symbol_p;
   8229 
   8230       r_symndx = ELF_R_SYM (abfd, rel->r_info);
   8231       r_type = ELF_R_TYPE (abfd, rel->r_info);
   8232 
   8233       if (r_symndx < extsymoff)
   8234 	h = NULL;
   8235       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
   8236 	{
   8237 	  (*_bfd_error_handler)
   8238 	    (_("%B: Malformed reloc detected for section %s"),
   8239 	     abfd, name);
   8240 	  bfd_set_error (bfd_error_bad_value);
   8241 	  return FALSE;
   8242 	}
   8243       else
   8244 	{
   8245 	  h = sym_hashes[r_symndx - extsymoff];
   8246 	  if (h != NULL)
   8247 	    {
   8248 	      while (h->root.type == bfd_link_hash_indirect
   8249 		     || h->root.type == bfd_link_hash_warning)
   8250 		h = (struct elf_link_hash_entry *) h->root.u.i.link;
   8251 
   8252 	      /* PR15323, ref flags aren't set for references in the
   8253 		 same object.  */
   8254 	      h->root.non_ir_ref = 1;
   8255 	    }
   8256 	}
   8257 
   8258       /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
   8259 	 relocation into a dynamic one.  */
   8260       can_make_dynamic_p = FALSE;
   8261 
   8262       /* Set CALL_RELOC_P to true if the relocation is for a call,
   8263 	 and if pointer equality therefore doesn't matter.  */
   8264       call_reloc_p = FALSE;
   8265 
   8266       /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
   8267 	 into account when deciding how to define the symbol.
   8268 	 Relocations in nonallocatable sections such as .pdr and
   8269 	 .debug* should have no effect.  */
   8270       constrain_symbol_p = ((sec->flags & SEC_ALLOC) != 0);
   8271 
   8272       switch (r_type)
   8273 	{
   8274 	case R_MIPS_CALL16:
   8275 	case R_MIPS_CALL_HI16:
   8276 	case R_MIPS_CALL_LO16:
   8277 	case R_MIPS16_CALL16:
   8278 	case R_MICROMIPS_CALL16:
   8279 	case R_MICROMIPS_CALL_HI16:
   8280 	case R_MICROMIPS_CALL_LO16:
   8281 	  call_reloc_p = TRUE;
   8282 	  /* Fall through.  */
   8283 
   8284 	case R_MIPS_GOT16:
   8285 	case R_MIPS_GOT_HI16:
   8286 	case R_MIPS_GOT_LO16:
   8287 	case R_MIPS_GOT_PAGE:
   8288 	case R_MIPS_GOT_OFST:
   8289 	case R_MIPS_GOT_DISP:
   8290 	case R_MIPS_TLS_GOTTPREL:
   8291 	case R_MIPS_TLS_GD:
   8292 	case R_MIPS_TLS_LDM:
   8293 	case R_MIPS16_GOT16:
   8294 	case R_MIPS16_TLS_GOTTPREL:
   8295 	case R_MIPS16_TLS_GD:
   8296 	case R_MIPS16_TLS_LDM:
   8297 	case R_MICROMIPS_GOT16:
   8298 	case R_MICROMIPS_GOT_HI16:
   8299 	case R_MICROMIPS_GOT_LO16:
   8300 	case R_MICROMIPS_GOT_PAGE:
   8301 	case R_MICROMIPS_GOT_OFST:
   8302 	case R_MICROMIPS_GOT_DISP:
   8303 	case R_MICROMIPS_TLS_GOTTPREL:
   8304 	case R_MICROMIPS_TLS_GD:
   8305 	case R_MICROMIPS_TLS_LDM:
   8306 	  if (dynobj == NULL)
   8307 	    elf_hash_table (info)->dynobj = dynobj = abfd;
   8308 	  if (!mips_elf_create_got_section (dynobj, info))
   8309 	    return FALSE;
   8310 	  if (htab->is_vxworks && !info->shared)
   8311 	    {
   8312 	      (*_bfd_error_handler)
   8313 		(_("%B: GOT reloc at 0x%lx not expected in executables"),
   8314 		 abfd, (unsigned long) rel->r_offset);
   8315 	      bfd_set_error (bfd_error_bad_value);
   8316 	      return FALSE;
   8317 	    }
   8318 	  can_make_dynamic_p = TRUE;
   8319 	  break;
   8320 
   8321 	case R_MIPS_NONE:
   8322 	case R_MIPS_JALR:
   8323 	case R_MICROMIPS_JALR:
   8324 	  /* These relocations have empty fields and are purely there to
   8325 	     provide link information.  The symbol value doesn't matter.  */
   8326 	  constrain_symbol_p = FALSE;
   8327 	  break;
   8328 
   8329 	case R_MIPS_GPREL16:
   8330 	case R_MIPS_GPREL32:
   8331 	case R_MIPS16_GPREL:
   8332 	case R_MICROMIPS_GPREL16:
   8333 	  /* GP-relative relocations always resolve to a definition in a
   8334 	     regular input file, ignoring the one-definition rule.  This is
   8335 	     important for the GP setup sequence in NewABI code, which
   8336 	     always resolves to a local function even if other relocations
   8337 	     against the symbol wouldn't.  */
   8338 	  constrain_symbol_p = FALSE;
   8339 	  break;
   8340 
   8341 	case R_MIPS_32:
   8342 	case R_MIPS_REL32:
   8343 	case R_MIPS_64:
   8344 	  /* In VxWorks executables, references to external symbols
   8345 	     must be handled using copy relocs or PLT entries; it is not
   8346 	     possible to convert this relocation into a dynamic one.
   8347 
   8348 	     For executables that use PLTs and copy-relocs, we have a
   8349 	     choice between converting the relocation into a dynamic
   8350 	     one or using copy relocations or PLT entries.  It is
   8351 	     usually better to do the former, unless the relocation is
   8352 	     against a read-only section.  */
   8353 	  if ((info->shared
   8354 	       || (h != NULL
   8355 		   && !htab->is_vxworks
   8356 		   && strcmp (h->root.root.string, "__gnu_local_gp") != 0
   8357 		   && !(!info->nocopyreloc
   8358 			&& !PIC_OBJECT_P (abfd)
   8359 			&& MIPS_ELF_READONLY_SECTION (sec))))
   8360 	      && (sec->flags & SEC_ALLOC) != 0)
   8361 	    {
   8362 	      can_make_dynamic_p = TRUE;
   8363 	      if (dynobj == NULL)
   8364 		elf_hash_table (info)->dynobj = dynobj = abfd;
   8365 	    }
   8366 	  break;
   8367 
   8368 	case R_MIPS_26:
   8369 	case R_MIPS_PC16:
   8370 	case R_MIPS_PC21_S2:
   8371 	case R_MIPS_PC26_S2:
   8372 	case R_MIPS16_26:
   8373 	case R_MICROMIPS_26_S1:
   8374 	case R_MICROMIPS_PC7_S1:
   8375 	case R_MICROMIPS_PC10_S1:
   8376 	case R_MICROMIPS_PC16_S1:
   8377 	case R_MICROMIPS_PC23_S2:
   8378 	  call_reloc_p = TRUE;
   8379 	  break;
   8380 	}
   8381 
   8382       if (h)
   8383 	{
   8384 	  if (constrain_symbol_p)
   8385 	    {
   8386 	      if (!can_make_dynamic_p)
   8387 		((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1;
   8388 
   8389 	      if (!call_reloc_p)
   8390 		h->pointer_equality_needed = 1;
   8391 
   8392 	      /* We must not create a stub for a symbol that has
   8393 		 relocations related to taking the function's address.
   8394 		 This doesn't apply to VxWorks, where CALL relocs refer
   8395 		 to a .got.plt entry instead of a normal .got entry.  */
   8396 	      if (!htab->is_vxworks && (!can_make_dynamic_p || !call_reloc_p))
   8397 		((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
   8398 	    }
   8399 
   8400 	  /* Relocations against the special VxWorks __GOTT_BASE__ and
   8401 	     __GOTT_INDEX__ symbols must be left to the loader.  Allocate
   8402 	     room for them in .rela.dyn.  */
   8403 	  if (is_gott_symbol (info, h))
   8404 	    {
   8405 	      if (sreloc == NULL)
   8406 		{
   8407 		  sreloc = mips_elf_rel_dyn_section (info, TRUE);
   8408 		  if (sreloc == NULL)
   8409 		    return FALSE;
   8410 		}
   8411 	      mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
   8412 	      if (MIPS_ELF_READONLY_SECTION (sec))
   8413 		/* We tell the dynamic linker that there are
   8414 		   relocations against the text segment.  */
   8415 		info->flags |= DF_TEXTREL;
   8416 	    }
   8417 	}
   8418       else if (call_lo16_reloc_p (r_type)
   8419 	       || got_lo16_reloc_p (r_type)
   8420 	       || got_disp_reloc_p (r_type)
   8421 	       || (got16_reloc_p (r_type) && htab->is_vxworks))
   8422 	{
   8423 	  /* We may need a local GOT entry for this relocation.  We
   8424 	     don't count R_MIPS_GOT_PAGE because we can estimate the
   8425 	     maximum number of pages needed by looking at the size of
   8426 	     the segment.  Similar comments apply to R_MIPS*_GOT16 and
   8427 	     R_MIPS*_CALL16, except on VxWorks, where GOT relocations
   8428 	     always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
   8429 	     R_MIPS_CALL_HI16 because these are always followed by an
   8430 	     R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
   8431 	  if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
   8432 						 rel->r_addend, info, r_type))
   8433 	    return FALSE;
   8434 	}
   8435 
   8436       if (h != NULL
   8437 	  && mips_elf_relocation_needs_la25_stub (abfd, r_type,
   8438 						  ELF_ST_IS_MIPS16 (h->other)))
   8439 	((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
   8440 
   8441       switch (r_type)
   8442 	{
   8443 	case R_MIPS_CALL16:
   8444 	case R_MIPS16_CALL16:
   8445 	case R_MICROMIPS_CALL16:
   8446 	  if (h == NULL)
   8447 	    {
   8448 	      (*_bfd_error_handler)
   8449 		(_("%B: CALL16 reloc at 0x%lx not against global symbol"),
   8450 		 abfd, (unsigned long) rel->r_offset);
   8451 	      bfd_set_error (bfd_error_bad_value);
   8452 	      return FALSE;
   8453 	    }
   8454 	  /* Fall through.  */
   8455 
   8456 	case R_MIPS_CALL_HI16:
   8457 	case R_MIPS_CALL_LO16:
   8458 	case R_MICROMIPS_CALL_HI16:
   8459 	case R_MICROMIPS_CALL_LO16:
   8460 	  if (h != NULL)
   8461 	    {
   8462 	      /* Make sure there is room in the regular GOT to hold the
   8463 		 function's address.  We may eliminate it in favour of
   8464 		 a .got.plt entry later; see mips_elf_count_got_symbols.  */
   8465 	      if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
   8466 						      r_type))
   8467 		return FALSE;
   8468 
   8469 	      /* We need a stub, not a plt entry for the undefined
   8470 		 function.  But we record it as if it needs plt.  See
   8471 		 _bfd_elf_adjust_dynamic_symbol.  */
   8472 	      h->needs_plt = 1;
   8473 	      h->type = STT_FUNC;
   8474 	    }
   8475 	  break;
   8476 
   8477 	case R_MIPS_GOT_PAGE:
   8478 	case R_MICROMIPS_GOT_PAGE:
   8479 	case R_MIPS16_GOT16:
   8480 	case R_MIPS_GOT16:
   8481 	case R_MIPS_GOT_HI16:
   8482 	case R_MIPS_GOT_LO16:
   8483 	case R_MICROMIPS_GOT16:
   8484 	case R_MICROMIPS_GOT_HI16:
   8485 	case R_MICROMIPS_GOT_LO16:
   8486 	  if (!h || got_page_reloc_p (r_type))
   8487 	    {
   8488 	      /* This relocation needs (or may need, if h != NULL) a
   8489 		 page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
   8490 		 know for sure until we know whether the symbol is
   8491 		 preemptible.  */
   8492 	      if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
   8493 		{
   8494 		  if (!mips_elf_get_section_contents (abfd, sec, &contents))
   8495 		    return FALSE;
   8496 		  howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
   8497 		  addend = mips_elf_read_rel_addend (abfd, rel,
   8498 						     howto, contents);
   8499 		  if (got16_reloc_p (r_type))
   8500 		    mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
   8501 						  contents, &addend);
   8502 		  else
   8503 		    addend <<= howto->rightshift;
   8504 		}
   8505 	      else
   8506 		addend = rel->r_addend;
   8507 	      if (!mips_elf_record_got_page_ref (info, abfd, r_symndx,
   8508 						 h, addend))
   8509 		return FALSE;
   8510 
   8511 	      if (h)
   8512 		{
   8513 		  struct mips_elf_link_hash_entry *hmips =
   8514 		    (struct mips_elf_link_hash_entry *) h;
   8515 
   8516 		  /* This symbol is definitely not overridable.  */
   8517 		  if (hmips->root.def_regular
   8518 		      && ! (info->shared && ! info->symbolic
   8519 			    && ! hmips->root.forced_local))
   8520 		    h = NULL;
   8521 		}
   8522 	    }
   8523 	  /* If this is a global, overridable symbol, GOT_PAGE will
   8524 	     decay to GOT_DISP, so we'll need a GOT entry for it.  */
   8525 	  /* Fall through.  */
   8526 
   8527 	case R_MIPS_GOT_DISP:
   8528 	case R_MICROMIPS_GOT_DISP:
   8529 	  if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
   8530 						       FALSE, r_type))
   8531 	    return FALSE;
   8532 	  break;
   8533 
   8534 	case R_MIPS_TLS_GOTTPREL:
   8535 	case R_MIPS16_TLS_GOTTPREL:
   8536 	case R_MICROMIPS_TLS_GOTTPREL:
   8537 	  if (info->shared)
   8538 	    info->flags |= DF_STATIC_TLS;
   8539 	  /* Fall through */
   8540 
   8541 	case R_MIPS_TLS_LDM:
   8542 	case R_MIPS16_TLS_LDM:
   8543 	case R_MICROMIPS_TLS_LDM:
   8544 	  if (tls_ldm_reloc_p (r_type))
   8545 	    {
   8546 	      r_symndx = STN_UNDEF;
   8547 	      h = NULL;
   8548 	    }
   8549 	  /* Fall through */
   8550 
   8551 	case R_MIPS_TLS_GD:
   8552 	case R_MIPS16_TLS_GD:
   8553 	case R_MICROMIPS_TLS_GD:
   8554 	  /* This symbol requires a global offset table entry, or two
   8555 	     for TLS GD relocations.  */
   8556 	  if (h != NULL)
   8557 	    {
   8558 	      if (!mips_elf_record_global_got_symbol (h, abfd, info,
   8559 						      FALSE, r_type))
   8560 		return FALSE;
   8561 	    }
   8562 	  else
   8563 	    {
   8564 	      if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
   8565 						     rel->r_addend,
   8566 						     info, r_type))
   8567 		return FALSE;
   8568 	    }
   8569 	  break;
   8570 
   8571 	case R_MIPS_32:
   8572 	case R_MIPS_REL32:
   8573 	case R_MIPS_64:
   8574 	  /* In VxWorks executables, references to external symbols
   8575 	     are handled using copy relocs or PLT stubs, so there's
   8576 	     no need to add a .rela.dyn entry for this relocation.  */
   8577 	  if (can_make_dynamic_p)
   8578 	    {
   8579 	      if (sreloc == NULL)
   8580 		{
   8581 		  sreloc = mips_elf_rel_dyn_section (info, TRUE);
   8582 		  if (sreloc == NULL)
   8583 		    return FALSE;
   8584 		}
   8585 	      if (info->shared && h == NULL)
   8586 		{
   8587 		  /* When creating a shared object, we must copy these
   8588 		     reloc types into the output file as R_MIPS_REL32
   8589 		     relocs.  Make room for this reloc in .rel(a).dyn.  */
   8590 		  mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
   8591 		  if (MIPS_ELF_READONLY_SECTION (sec))
   8592 		    /* We tell the dynamic linker that there are
   8593 		       relocations against the text segment.  */
   8594 		    info->flags |= DF_TEXTREL;
   8595 		}
   8596 	      else
   8597 		{
   8598 		  struct mips_elf_link_hash_entry *hmips;
   8599 
   8600 		  /* For a shared object, we must copy this relocation
   8601 		     unless the symbol turns out to be undefined and
   8602 		     weak with non-default visibility, in which case
   8603 		     it will be left as zero.
   8604 
   8605 		     We could elide R_MIPS_REL32 for locally binding symbols
   8606 		     in shared libraries, but do not yet do so.
   8607 
   8608 		     For an executable, we only need to copy this
   8609 		     reloc if the symbol is defined in a dynamic
   8610 		     object.  */
   8611 		  hmips = (struct mips_elf_link_hash_entry *) h;
   8612 		  ++hmips->possibly_dynamic_relocs;
   8613 		  if (MIPS_ELF_READONLY_SECTION (sec))
   8614 		    /* We need it to tell the dynamic linker if there
   8615 		       are relocations against the text segment.  */
   8616 		    hmips->readonly_reloc = TRUE;
   8617 		}
   8618 	    }
   8619 
   8620 	  if (SGI_COMPAT (abfd))
   8621 	    mips_elf_hash_table (info)->compact_rel_size +=
   8622 	      sizeof (Elf32_External_crinfo);
   8623 	  break;
   8624 
   8625 	case R_MIPS_26:
   8626 	case R_MIPS_GPREL16:
   8627 	case R_MIPS_LITERAL:
   8628 	case R_MIPS_GPREL32:
   8629 	case R_MICROMIPS_26_S1:
   8630 	case R_MICROMIPS_GPREL16:
   8631 	case R_MICROMIPS_LITERAL:
   8632 	case R_MICROMIPS_GPREL7_S2:
   8633 	  if (SGI_COMPAT (abfd))
   8634 	    mips_elf_hash_table (info)->compact_rel_size +=
   8635 	      sizeof (Elf32_External_crinfo);
   8636 	  break;
   8637 
   8638 	  /* This relocation describes the C++ object vtable hierarchy.
   8639 	     Reconstruct it for later use during GC.  */
   8640 	case R_MIPS_GNU_VTINHERIT:
   8641 	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
   8642 	    return FALSE;
   8643 	  break;
   8644 
   8645 	  /* This relocation describes which C++ vtable entries are actually
   8646 	     used.  Record for later use during GC.  */
   8647 	case R_MIPS_GNU_VTENTRY:
   8648 	  BFD_ASSERT (h != NULL);
   8649 	  if (h != NULL
   8650 	      && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
   8651 	    return FALSE;
   8652 	  break;
   8653 
   8654 	default:
   8655 	  break;
   8656 	}
   8657 
   8658       /* Record the need for a PLT entry.  At this point we don't know
   8659          yet if we are going to create a PLT in the first place, but
   8660          we only record whether the relocation requires a standard MIPS
   8661          or a compressed code entry anyway.  If we don't make a PLT after
   8662          all, then we'll just ignore these arrangements.  Likewise if
   8663          a PLT entry is not created because the symbol is satisfied
   8664          locally.  */
   8665       if (h != NULL
   8666 	  && jal_reloc_p (r_type)
   8667 	  && !SYMBOL_CALLS_LOCAL (info, h))
   8668 	{
   8669 	  if (h->plt.plist == NULL)
   8670 	    h->plt.plist = mips_elf_make_plt_record (abfd);
   8671 	  if (h->plt.plist == NULL)
   8672 	    return FALSE;
   8673 
   8674 	  if (r_type == R_MIPS_26)
   8675 	    h->plt.plist->need_mips = TRUE;
   8676 	  else
   8677 	    h->plt.plist->need_comp = TRUE;
   8678 	}
   8679 
   8680       /* See if this reloc would need to refer to a MIPS16 hard-float stub,
   8681 	 if there is one.  We only need to handle global symbols here;
   8682 	 we decide whether to keep or delete stubs for local symbols
   8683 	 when processing the stub's relocations.  */
   8684       if (h != NULL
   8685 	  && !mips16_call_reloc_p (r_type)
   8686 	  && !section_allows_mips16_refs_p (sec))
   8687 	{
   8688 	  struct mips_elf_link_hash_entry *mh;
   8689 
   8690 	  mh = (struct mips_elf_link_hash_entry *) h;
   8691 	  mh->need_fn_stub = TRUE;
   8692 	}
   8693 
   8694       /* Refuse some position-dependent relocations when creating a
   8695 	 shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
   8696 	 not PIC, but we can create dynamic relocations and the result
   8697 	 will be fine.  Also do not refuse R_MIPS_LO16, which can be
   8698 	 combined with R_MIPS_GOT16.  */
   8699       if (info->shared)
   8700 	{
   8701 	  switch (r_type)
   8702 	    {
   8703 	    case R_MIPS16_HI16:
   8704 	    case R_MIPS_HI16:
   8705 	    case R_MIPS_HIGHER:
   8706 	    case R_MIPS_HIGHEST:
   8707 	    case R_MICROMIPS_HI16:
   8708 	    case R_MICROMIPS_HIGHER:
   8709 	    case R_MICROMIPS_HIGHEST:
   8710 	      /* Don't refuse a high part relocation if it's against
   8711 		 no symbol (e.g. part of a compound relocation).  */
   8712 	      if (r_symndx == STN_UNDEF)
   8713 		break;
   8714 
   8715 	      /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
   8716 		 and has a special meaning.  */
   8717 	      if (!NEWABI_P (abfd) && h != NULL
   8718 		  && strcmp (h->root.root.string, "_gp_disp") == 0)
   8719 		break;
   8720 
   8721 	      /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks.  */
   8722 	      if (is_gott_symbol (info, h))
   8723 		break;
   8724 
   8725 	      /* FALLTHROUGH */
   8726 
   8727 	    case R_MIPS16_26:
   8728 	    case R_MIPS_26:
   8729 	    case R_MICROMIPS_26_S1:
   8730 	      howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
   8731 	      (*_bfd_error_handler)
   8732 		(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
   8733 		 abfd, howto->name,
   8734 		 (h) ? h->root.root.string : "a local symbol");
   8735 	      bfd_set_error (bfd_error_bad_value);
   8736 	      return FALSE;
   8737 	    default:
   8738 	      break;
   8739 	    }
   8740 	}
   8741     }
   8742 
   8743   return TRUE;
   8744 }
   8745 
   8746 bfd_boolean
   8748 _bfd_mips_relax_section (bfd *abfd, asection *sec,
   8749 			 struct bfd_link_info *link_info,
   8750 			 bfd_boolean *again)
   8751 {
   8752   Elf_Internal_Rela *internal_relocs;
   8753   Elf_Internal_Rela *irel, *irelend;
   8754   Elf_Internal_Shdr *symtab_hdr;
   8755   bfd_byte *contents = NULL;
   8756   size_t extsymoff;
   8757   bfd_boolean changed_contents = FALSE;
   8758   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
   8759   Elf_Internal_Sym *isymbuf = NULL;
   8760 
   8761   /* We are not currently changing any sizes, so only one pass.  */
   8762   *again = FALSE;
   8763 
   8764   if (link_info->relocatable)
   8765     return TRUE;
   8766 
   8767   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
   8768 					       link_info->keep_memory);
   8769   if (internal_relocs == NULL)
   8770     return TRUE;
   8771 
   8772   irelend = internal_relocs + sec->reloc_count
   8773     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
   8774   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   8775   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
   8776 
   8777   for (irel = internal_relocs; irel < irelend; irel++)
   8778     {
   8779       bfd_vma symval;
   8780       bfd_signed_vma sym_offset;
   8781       unsigned int r_type;
   8782       unsigned long r_symndx;
   8783       asection *sym_sec;
   8784       unsigned long instruction;
   8785 
   8786       /* Turn jalr into bgezal, and jr into beq, if they're marked
   8787 	 with a JALR relocation, that indicate where they jump to.
   8788 	 This saves some pipeline bubbles.  */
   8789       r_type = ELF_R_TYPE (abfd, irel->r_info);
   8790       if (r_type != R_MIPS_JALR)
   8791 	continue;
   8792 
   8793       r_symndx = ELF_R_SYM (abfd, irel->r_info);
   8794       /* Compute the address of the jump target.  */
   8795       if (r_symndx >= extsymoff)
   8796 	{
   8797 	  struct mips_elf_link_hash_entry *h
   8798 	    = ((struct mips_elf_link_hash_entry *)
   8799 	       elf_sym_hashes (abfd) [r_symndx - extsymoff]);
   8800 
   8801 	  while (h->root.root.type == bfd_link_hash_indirect
   8802 		 || h->root.root.type == bfd_link_hash_warning)
   8803 	    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
   8804 
   8805 	  /* If a symbol is undefined, or if it may be overridden,
   8806 	     skip it.  */
   8807 	  if (! ((h->root.root.type == bfd_link_hash_defined
   8808 		  || h->root.root.type == bfd_link_hash_defweak)
   8809 		 && h->root.root.u.def.section)
   8810 	      || (link_info->shared && ! link_info->symbolic
   8811 		  && !h->root.forced_local))
   8812 	    continue;
   8813 
   8814 	  sym_sec = h->root.root.u.def.section;
   8815 	  if (sym_sec->output_section)
   8816 	    symval = (h->root.root.u.def.value
   8817 		      + sym_sec->output_section->vma
   8818 		      + sym_sec->output_offset);
   8819 	  else
   8820 	    symval = h->root.root.u.def.value;
   8821 	}
   8822       else
   8823 	{
   8824 	  Elf_Internal_Sym *isym;
   8825 
   8826 	  /* Read this BFD's symbols if we haven't done so already.  */
   8827 	  if (isymbuf == NULL && symtab_hdr->sh_info != 0)
   8828 	    {
   8829 	      isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
   8830 	      if (isymbuf == NULL)
   8831 		isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
   8832 						symtab_hdr->sh_info, 0,
   8833 						NULL, NULL, NULL);
   8834 	      if (isymbuf == NULL)
   8835 		goto relax_return;
   8836 	    }
   8837 
   8838 	  isym = isymbuf + r_symndx;
   8839 	  if (isym->st_shndx == SHN_UNDEF)
   8840 	    continue;
   8841 	  else if (isym->st_shndx == SHN_ABS)
   8842 	    sym_sec = bfd_abs_section_ptr;
   8843 	  else if (isym->st_shndx == SHN_COMMON)
   8844 	    sym_sec = bfd_com_section_ptr;
   8845 	  else
   8846 	    sym_sec
   8847 	      = bfd_section_from_elf_index (abfd, isym->st_shndx);
   8848 	  symval = isym->st_value
   8849 	    + sym_sec->output_section->vma
   8850 	    + sym_sec->output_offset;
   8851 	}
   8852 
   8853       /* Compute branch offset, from delay slot of the jump to the
   8854 	 branch target.  */
   8855       sym_offset = (symval + irel->r_addend)
   8856 	- (sec_start + irel->r_offset + 4);
   8857 
   8858       /* Branch offset must be properly aligned.  */
   8859       if ((sym_offset & 3) != 0)
   8860 	continue;
   8861 
   8862       sym_offset >>= 2;
   8863 
   8864       /* Check that it's in range.  */
   8865       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
   8866 	continue;
   8867 
   8868       /* Get the section contents if we haven't done so already.  */
   8869       if (!mips_elf_get_section_contents (abfd, sec, &contents))
   8870 	goto relax_return;
   8871 
   8872       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
   8873 
   8874       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
   8875       if ((instruction & 0xfc1fffff) == 0x0000f809)
   8876 	instruction = 0x04110000;
   8877       /* If it was jr <reg>, turn it into b <target>.  */
   8878       else if ((instruction & 0xfc1fffff) == 0x00000008)
   8879 	instruction = 0x10000000;
   8880       else
   8881 	continue;
   8882 
   8883       instruction |= (sym_offset & 0xffff);
   8884       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
   8885       changed_contents = TRUE;
   8886     }
   8887 
   8888   if (contents != NULL
   8889       && elf_section_data (sec)->this_hdr.contents != contents)
   8890     {
   8891       if (!changed_contents && !link_info->keep_memory)
   8892         free (contents);
   8893       else
   8894         {
   8895           /* Cache the section contents for elf_link_input_bfd.  */
   8896           elf_section_data (sec)->this_hdr.contents = contents;
   8897         }
   8898     }
   8899   return TRUE;
   8900 
   8901  relax_return:
   8902   if (contents != NULL
   8903       && elf_section_data (sec)->this_hdr.contents != contents)
   8904     free (contents);
   8905   return FALSE;
   8906 }
   8907 
   8908 /* Allocate space for global sym dynamic relocs.  */
   8910 
   8911 static bfd_boolean
   8912 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
   8913 {
   8914   struct bfd_link_info *info = inf;
   8915   bfd *dynobj;
   8916   struct mips_elf_link_hash_entry *hmips;
   8917   struct mips_elf_link_hash_table *htab;
   8918 
   8919   htab = mips_elf_hash_table (info);
   8920   BFD_ASSERT (htab != NULL);
   8921 
   8922   dynobj = elf_hash_table (info)->dynobj;
   8923   hmips = (struct mips_elf_link_hash_entry *) h;
   8924 
   8925   /* VxWorks executables are handled elsewhere; we only need to
   8926      allocate relocations in shared objects.  */
   8927   if (htab->is_vxworks && !info->shared)
   8928     return TRUE;
   8929 
   8930   /* Ignore indirect symbols.  All relocations against such symbols
   8931      will be redirected to the target symbol.  */
   8932   if (h->root.type == bfd_link_hash_indirect)
   8933     return TRUE;
   8934 
   8935   /* If this symbol is defined in a dynamic object, or we are creating
   8936      a shared library, we will need to copy any R_MIPS_32 or
   8937      R_MIPS_REL32 relocs against it into the output file.  */
   8938   if (! info->relocatable
   8939       && hmips->possibly_dynamic_relocs != 0
   8940       && (h->root.type == bfd_link_hash_defweak
   8941 	  || (!h->def_regular && !ELF_COMMON_DEF_P (h))
   8942 	  || info->shared))
   8943     {
   8944       bfd_boolean do_copy = TRUE;
   8945 
   8946       if (h->root.type == bfd_link_hash_undefweak)
   8947 	{
   8948 	  /* Do not copy relocations for undefined weak symbols with
   8949 	     non-default visibility.  */
   8950 	  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
   8951 	    do_copy = FALSE;
   8952 
   8953 	  /* Make sure undefined weak symbols are output as a dynamic
   8954 	     symbol in PIEs.  */
   8955 	  else if (h->dynindx == -1 && !h->forced_local)
   8956 	    {
   8957 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
   8958 		return FALSE;
   8959 	    }
   8960 	}
   8961 
   8962       if (do_copy)
   8963 	{
   8964 	  /* Even though we don't directly need a GOT entry for this symbol,
   8965 	     the SVR4 psABI requires it to have a dynamic symbol table
   8966 	     index greater that DT_MIPS_GOTSYM if there are dynamic
   8967 	     relocations against it.
   8968 
   8969 	     VxWorks does not enforce the same mapping between the GOT
   8970 	     and the symbol table, so the same requirement does not
   8971 	     apply there.  */
   8972 	  if (!htab->is_vxworks)
   8973 	    {
   8974 	      if (hmips->global_got_area > GGA_RELOC_ONLY)
   8975 		hmips->global_got_area = GGA_RELOC_ONLY;
   8976 	      hmips->got_only_for_calls = FALSE;
   8977 	    }
   8978 
   8979 	  mips_elf_allocate_dynamic_relocations
   8980 	    (dynobj, info, hmips->possibly_dynamic_relocs);
   8981 	  if (hmips->readonly_reloc)
   8982 	    /* We tell the dynamic linker that there are relocations
   8983 	       against the text segment.  */
   8984 	    info->flags |= DF_TEXTREL;
   8985 	}
   8986     }
   8987 
   8988   return TRUE;
   8989 }
   8990 
   8991 /* Adjust a symbol defined by a dynamic object and referenced by a
   8992    regular object.  The current definition is in some section of the
   8993    dynamic object, but we're not including those sections.  We have to
   8994    change the definition to something the rest of the link can
   8995    understand.  */
   8996 
   8997 bfd_boolean
   8998 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
   8999 				     struct elf_link_hash_entry *h)
   9000 {
   9001   bfd *dynobj;
   9002   struct mips_elf_link_hash_entry *hmips;
   9003   struct mips_elf_link_hash_table *htab;
   9004 
   9005   htab = mips_elf_hash_table (info);
   9006   BFD_ASSERT (htab != NULL);
   9007 
   9008   dynobj = elf_hash_table (info)->dynobj;
   9009   hmips = (struct mips_elf_link_hash_entry *) h;
   9010 
   9011   /* Make sure we know what is going on here.  */
   9012   BFD_ASSERT (dynobj != NULL
   9013 	      && (h->needs_plt
   9014 		  || h->u.weakdef != NULL
   9015 		  || (h->def_dynamic
   9016 		      && h->ref_regular
   9017 		      && !h->def_regular)));
   9018 
   9019   hmips = (struct mips_elf_link_hash_entry *) h;
   9020 
   9021   /* If there are call relocations against an externally-defined symbol,
   9022      see whether we can create a MIPS lazy-binding stub for it.  We can
   9023      only do this if all references to the function are through call
   9024      relocations, and in that case, the traditional lazy-binding stubs
   9025      are much more efficient than PLT entries.
   9026 
   9027      Traditional stubs are only available on SVR4 psABI-based systems;
   9028      VxWorks always uses PLTs instead.  */
   9029   if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
   9030     {
   9031       if (! elf_hash_table (info)->dynamic_sections_created)
   9032 	return TRUE;
   9033 
   9034       /* If this symbol is not defined in a regular file, then set
   9035 	 the symbol to the stub location.  This is required to make
   9036 	 function pointers compare as equal between the normal
   9037 	 executable and the shared library.  */
   9038       if (!h->def_regular)
   9039 	{
   9040 	  hmips->needs_lazy_stub = TRUE;
   9041 	  htab->lazy_stub_count++;
   9042 	  return TRUE;
   9043 	}
   9044     }
   9045   /* As above, VxWorks requires PLT entries for externally-defined
   9046      functions that are only accessed through call relocations.
   9047 
   9048      Both VxWorks and non-VxWorks targets also need PLT entries if there
   9049      are static-only relocations against an externally-defined function.
   9050      This can technically occur for shared libraries if there are
   9051      branches to the symbol, although it is unlikely that this will be
   9052      used in practice due to the short ranges involved.  It can occur
   9053      for any relative or absolute relocation in executables; in that
   9054      case, the PLT entry becomes the function's canonical address.  */
   9055   else if (((h->needs_plt && !hmips->no_fn_stub)
   9056 	    || (h->type == STT_FUNC && hmips->has_static_relocs))
   9057 	   && htab->use_plts_and_copy_relocs
   9058 	   && !SYMBOL_CALLS_LOCAL (info, h)
   9059 	   && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
   9060 		&& h->root.type == bfd_link_hash_undefweak))
   9061     {
   9062       bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
   9063       bfd_boolean newabi_p = NEWABI_P (info->output_bfd);
   9064 
   9065       /* If this is the first symbol to need a PLT entry, then make some
   9066          basic setup.  Also work out PLT entry sizes.  We'll need them
   9067          for PLT offset calculations.  */
   9068       if (htab->plt_mips_offset + htab->plt_comp_offset == 0)
   9069 	{
   9070 	  BFD_ASSERT (htab->sgotplt->size == 0);
   9071 	  BFD_ASSERT (htab->plt_got_index == 0);
   9072 
   9073 	  /* If we're using the PLT additions to the psABI, each PLT
   9074 	     entry is 16 bytes and the PLT0 entry is 32 bytes.
   9075 	     Encourage better cache usage by aligning.  We do this
   9076 	     lazily to avoid pessimizing traditional objects.  */
   9077 	  if (!htab->is_vxworks
   9078 	      && !bfd_set_section_alignment (dynobj, htab->splt, 5))
   9079 	    return FALSE;
   9080 
   9081 	  /* Make sure that .got.plt is word-aligned.  We do this lazily
   9082 	     for the same reason as above.  */
   9083 	  if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
   9084 					  MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
   9085 	    return FALSE;
   9086 
   9087 	  /* On non-VxWorks targets, the first two entries in .got.plt
   9088 	     are reserved.  */
   9089 	  if (!htab->is_vxworks)
   9090 	    htab->plt_got_index
   9091 	      += (get_elf_backend_data (dynobj)->got_header_size
   9092 		  / MIPS_ELF_GOT_SIZE (dynobj));
   9093 
   9094 	  /* On VxWorks, also allocate room for the header's
   9095 	     .rela.plt.unloaded entries.  */
   9096 	  if (htab->is_vxworks && !info->shared)
   9097 	    htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
   9098 
   9099 	  /* Now work out the sizes of individual PLT entries.  */
   9100 	  if (htab->is_vxworks && info->shared)
   9101 	    htab->plt_mips_entry_size
   9102 	      = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
   9103 	  else if (htab->is_vxworks)
   9104 	    htab->plt_mips_entry_size
   9105 	      = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
   9106 	  else if (newabi_p)
   9107 	    htab->plt_mips_entry_size
   9108 	      = 4 * ARRAY_SIZE (mips_exec_plt_entry);
   9109 	  else if (!micromips_p)
   9110 	    {
   9111 	      htab->plt_mips_entry_size
   9112 		= 4 * ARRAY_SIZE (mips_exec_plt_entry);
   9113 	      htab->plt_comp_entry_size
   9114 		= 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
   9115 	    }
   9116 	  else if (htab->insn32)
   9117 	    {
   9118 	      htab->plt_mips_entry_size
   9119 		= 4 * ARRAY_SIZE (mips_exec_plt_entry);
   9120 	      htab->plt_comp_entry_size
   9121 		= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
   9122 	    }
   9123 	  else
   9124 	    {
   9125 	      htab->plt_mips_entry_size
   9126 		= 4 * ARRAY_SIZE (mips_exec_plt_entry);
   9127 	      htab->plt_comp_entry_size
   9128 		= 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
   9129 	    }
   9130 	}
   9131 
   9132       if (h->plt.plist == NULL)
   9133 	h->plt.plist = mips_elf_make_plt_record (dynobj);
   9134       if (h->plt.plist == NULL)
   9135 	return FALSE;
   9136 
   9137       /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
   9138          n32 or n64, so always use a standard entry there.
   9139 
   9140          If the symbol has a MIPS16 call stub and gets a PLT entry, then
   9141          all MIPS16 calls will go via that stub, and there is no benefit
   9142          to having a MIPS16 entry.  And in the case of call_stub a
   9143          standard entry actually has to be used as the stub ends with a J
   9144          instruction.  */
   9145       if (newabi_p
   9146 	  || htab->is_vxworks
   9147 	  || hmips->call_stub
   9148 	  || hmips->call_fp_stub)
   9149 	{
   9150 	  h->plt.plist->need_mips = TRUE;
   9151 	  h->plt.plist->need_comp = FALSE;
   9152 	}
   9153 
   9154       /* Otherwise, if there are no direct calls to the function, we
   9155          have a free choice of whether to use standard or compressed
   9156          entries.  Prefer microMIPS entries if the object is known to
   9157          contain microMIPS code, so that it becomes possible to create
   9158          pure microMIPS binaries.  Prefer standard entries otherwise,
   9159          because MIPS16 ones are no smaller and are usually slower.  */
   9160       if (!h->plt.plist->need_mips && !h->plt.plist->need_comp)
   9161 	{
   9162 	  if (micromips_p)
   9163 	    h->plt.plist->need_comp = TRUE;
   9164 	  else
   9165 	    h->plt.plist->need_mips = TRUE;
   9166 	}
   9167 
   9168       if (h->plt.plist->need_mips)
   9169 	{
   9170 	  h->plt.plist->mips_offset = htab->plt_mips_offset;
   9171 	  htab->plt_mips_offset += htab->plt_mips_entry_size;
   9172 	}
   9173       if (h->plt.plist->need_comp)
   9174 	{
   9175 	  h->plt.plist->comp_offset = htab->plt_comp_offset;
   9176 	  htab->plt_comp_offset += htab->plt_comp_entry_size;
   9177 	}
   9178 
   9179       /* Reserve the corresponding .got.plt entry now too.  */
   9180       h->plt.plist->gotplt_index = htab->plt_got_index++;
   9181 
   9182       /* If the output file has no definition of the symbol, set the
   9183 	 symbol's value to the address of the stub.  */
   9184       if (!info->shared && !h->def_regular)
   9185 	hmips->use_plt_entry = TRUE;
   9186 
   9187       /* Make room for the R_MIPS_JUMP_SLOT relocation.  */
   9188       htab->srelplt->size += (htab->is_vxworks
   9189 			      ? MIPS_ELF_RELA_SIZE (dynobj)
   9190 			      : MIPS_ELF_REL_SIZE (dynobj));
   9191 
   9192       /* Make room for the .rela.plt.unloaded relocations.  */
   9193       if (htab->is_vxworks && !info->shared)
   9194 	htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
   9195 
   9196       /* All relocations against this symbol that could have been made
   9197 	 dynamic will now refer to the PLT entry instead.  */
   9198       hmips->possibly_dynamic_relocs = 0;
   9199 
   9200       return TRUE;
   9201     }
   9202 
   9203   /* If this is a weak symbol, and there is a real definition, the
   9204      processor independent code will have arranged for us to see the
   9205      real definition first, and we can just use the same value.  */
   9206   if (h->u.weakdef != NULL)
   9207     {
   9208       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
   9209 		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
   9210       h->root.u.def.section = h->u.weakdef->root.u.def.section;
   9211       h->root.u.def.value = h->u.weakdef->root.u.def.value;
   9212       return TRUE;
   9213     }
   9214 
   9215   /* Otherwise, there is nothing further to do for symbols defined
   9216      in regular objects.  */
   9217   if (h->def_regular)
   9218     return TRUE;
   9219 
   9220   /* There's also nothing more to do if we'll convert all relocations
   9221      against this symbol into dynamic relocations.  */
   9222   if (!hmips->has_static_relocs)
   9223     return TRUE;
   9224 
   9225   /* We're now relying on copy relocations.  Complain if we have
   9226      some that we can't convert.  */
   9227   if (!htab->use_plts_and_copy_relocs || info->shared)
   9228     {
   9229       (*_bfd_error_handler) (_("non-dynamic relocations refer to "
   9230 			       "dynamic symbol %s"),
   9231 			     h->root.root.string);
   9232       bfd_set_error (bfd_error_bad_value);
   9233       return FALSE;
   9234     }
   9235 
   9236   /* We must allocate the symbol in our .dynbss section, which will
   9237      become part of the .bss section of the executable.  There will be
   9238      an entry for this symbol in the .dynsym section.  The dynamic
   9239      object will contain position independent code, so all references
   9240      from the dynamic object to this symbol will go through the global
   9241      offset table.  The dynamic linker will use the .dynsym entry to
   9242      determine the address it must put in the global offset table, so
   9243      both the dynamic object and the regular object will refer to the
   9244      same memory location for the variable.  */
   9245 
   9246   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
   9247     {
   9248       if (htab->is_vxworks)
   9249 	htab->srelbss->size += sizeof (Elf32_External_Rela);
   9250       else
   9251 	mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
   9252       h->needs_copy = 1;
   9253     }
   9254 
   9255   /* All relocations against this symbol that could have been made
   9256      dynamic will now refer to the local copy instead.  */
   9257   hmips->possibly_dynamic_relocs = 0;
   9258 
   9259   return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
   9260 }
   9261 
   9262 /* This function is called after all the input files have been read,
   9264    and the input sections have been assigned to output sections.  We
   9265    check for any mips16 stub sections that we can discard.  */
   9266 
   9267 bfd_boolean
   9268 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
   9269 				    struct bfd_link_info *info)
   9270 {
   9271   asection *sect;
   9272   struct mips_elf_link_hash_table *htab;
   9273   struct mips_htab_traverse_info hti;
   9274 
   9275   htab = mips_elf_hash_table (info);
   9276   BFD_ASSERT (htab != NULL);
   9277 
   9278   /* The .reginfo section has a fixed size.  */
   9279   sect = bfd_get_section_by_name (output_bfd, ".reginfo");
   9280   if (sect != NULL)
   9281     bfd_set_section_size (output_bfd, sect, sizeof (Elf32_External_RegInfo));
   9282 
   9283   /* The .MIPS.abiflags section has a fixed size.  */
   9284   sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags");
   9285   if (sect != NULL)
   9286     bfd_set_section_size (output_bfd, sect, sizeof (Elf_External_ABIFlags_v0));
   9287 
   9288   hti.info = info;
   9289   hti.output_bfd = output_bfd;
   9290   hti.error = FALSE;
   9291   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
   9292 			       mips_elf_check_symbols, &hti);
   9293   if (hti.error)
   9294     return FALSE;
   9295 
   9296   return TRUE;
   9297 }
   9298 
   9299 /* If the link uses a GOT, lay it out and work out its size.  */
   9300 
   9301 static bfd_boolean
   9302 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
   9303 {
   9304   bfd *dynobj;
   9305   asection *s;
   9306   struct mips_got_info *g;
   9307   bfd_size_type loadable_size = 0;
   9308   bfd_size_type page_gotno;
   9309   bfd *ibfd;
   9310   struct mips_elf_traverse_got_arg tga;
   9311   struct mips_elf_link_hash_table *htab;
   9312 
   9313   htab = mips_elf_hash_table (info);
   9314   BFD_ASSERT (htab != NULL);
   9315 
   9316   s = htab->sgot;
   9317   if (s == NULL)
   9318     return TRUE;
   9319 
   9320   dynobj = elf_hash_table (info)->dynobj;
   9321   g = htab->got_info;
   9322 
   9323   /* Allocate room for the reserved entries.  VxWorks always reserves
   9324      3 entries; other objects only reserve 2 entries.  */
   9325   BFD_ASSERT (g->assigned_low_gotno == 0);
   9326   if (htab->is_vxworks)
   9327     htab->reserved_gotno = 3;
   9328   else
   9329     htab->reserved_gotno = 2;
   9330   g->local_gotno += htab->reserved_gotno;
   9331   g->assigned_low_gotno = htab->reserved_gotno;
   9332 
   9333   /* Decide which symbols need to go in the global part of the GOT and
   9334      count the number of reloc-only GOT symbols.  */
   9335   mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
   9336 
   9337   if (!mips_elf_resolve_final_got_entries (info, g))
   9338     return FALSE;
   9339 
   9340   /* Calculate the total loadable size of the output.  That
   9341      will give us the maximum number of GOT_PAGE entries
   9342      required.  */
   9343   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
   9344     {
   9345       asection *subsection;
   9346 
   9347       for (subsection = ibfd->sections;
   9348 	   subsection;
   9349 	   subsection = subsection->next)
   9350 	{
   9351 	  if ((subsection->flags & SEC_ALLOC) == 0)
   9352 	    continue;
   9353 	  loadable_size += ((subsection->size + 0xf)
   9354 			    &~ (bfd_size_type) 0xf);
   9355 	}
   9356     }
   9357 
   9358   if (htab->is_vxworks)
   9359     /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
   9360        relocations against local symbols evaluate to "G", and the EABI does
   9361        not include R_MIPS_GOT_PAGE.  */
   9362     page_gotno = 0;
   9363   else
   9364     /* Assume there are two loadable segments consisting of contiguous
   9365        sections.  Is 5 enough?  */
   9366     page_gotno = (loadable_size >> 16) + 5;
   9367 
   9368   /* Choose the smaller of the two page estimates; both are intended to be
   9369      conservative.  */
   9370   if (page_gotno > g->page_gotno)
   9371     page_gotno = g->page_gotno;
   9372 
   9373   g->local_gotno += page_gotno;
   9374   g->assigned_high_gotno = g->local_gotno - 1;
   9375 
   9376   s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
   9377   s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
   9378   s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
   9379 
   9380   /* VxWorks does not support multiple GOTs.  It initializes $gp to
   9381      __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
   9382      dynamic loader.  */
   9383   if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
   9384     {
   9385       if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
   9386 	return FALSE;
   9387     }
   9388   else
   9389     {
   9390       /* Record that all bfds use G.  This also has the effect of freeing
   9391 	 the per-bfd GOTs, which we no longer need.  */
   9392       for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
   9393 	if (mips_elf_bfd_got (ibfd, FALSE))
   9394 	  mips_elf_replace_bfd_got (ibfd, g);
   9395       mips_elf_replace_bfd_got (output_bfd, g);
   9396 
   9397       /* Set up TLS entries.  */
   9398       g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
   9399       tga.info = info;
   9400       tga.g = g;
   9401       tga.value = MIPS_ELF_GOT_SIZE (output_bfd);
   9402       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
   9403       if (!tga.g)
   9404 	return FALSE;
   9405       BFD_ASSERT (g->tls_assigned_gotno
   9406 		  == g->global_gotno + g->local_gotno + g->tls_gotno);
   9407 
   9408       /* Each VxWorks GOT entry needs an explicit relocation.  */
   9409       if (htab->is_vxworks && info->shared)
   9410 	g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno;
   9411 
   9412       /* Allocate room for the TLS relocations.  */
   9413       if (g->relocs)
   9414 	mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
   9415     }
   9416 
   9417   return TRUE;
   9418 }
   9419 
   9420 /* Estimate the size of the .MIPS.stubs section.  */
   9421 
   9422 static void
   9423 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
   9424 {
   9425   struct mips_elf_link_hash_table *htab;
   9426   bfd_size_type dynsymcount;
   9427 
   9428   htab = mips_elf_hash_table (info);
   9429   BFD_ASSERT (htab != NULL);
   9430 
   9431   if (htab->lazy_stub_count == 0)
   9432     return;
   9433 
   9434   /* IRIX rld assumes that a function stub isn't at the end of the .text
   9435      section, so add a dummy entry to the end.  */
   9436   htab->lazy_stub_count++;
   9437 
   9438   /* Get a worst-case estimate of the number of dynamic symbols needed.
   9439      At this point, dynsymcount does not account for section symbols
   9440      and count_section_dynsyms may overestimate the number that will
   9441      be needed.  */
   9442   dynsymcount = (elf_hash_table (info)->dynsymcount
   9443 		 + count_section_dynsyms (output_bfd, info));
   9444 
   9445   /* Determine the size of one stub entry.  There's no disadvantage
   9446      from using microMIPS code here, so for the sake of pure-microMIPS
   9447      binaries we prefer it whenever there's any microMIPS code in
   9448      output produced at all.  This has a benefit of stubs being
   9449      shorter by 4 bytes each too, unless in the insn32 mode.  */
   9450   if (!MICROMIPS_P (output_bfd))
   9451     htab->function_stub_size = (dynsymcount > 0x10000
   9452 				? MIPS_FUNCTION_STUB_BIG_SIZE
   9453 				: MIPS_FUNCTION_STUB_NORMAL_SIZE);
   9454   else if (htab->insn32)
   9455     htab->function_stub_size = (dynsymcount > 0x10000
   9456 				? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
   9457 				: MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE);
   9458   else
   9459     htab->function_stub_size = (dynsymcount > 0x10000
   9460 				? MICROMIPS_FUNCTION_STUB_BIG_SIZE
   9461 				: MICROMIPS_FUNCTION_STUB_NORMAL_SIZE);
   9462 
   9463   htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
   9464 }
   9465 
   9466 /* A mips_elf_link_hash_traverse callback for which DATA points to a
   9467    mips_htab_traverse_info.  If H needs a traditional MIPS lazy-binding
   9468    stub, allocate an entry in the stubs section.  */
   9469 
   9470 static bfd_boolean
   9471 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data)
   9472 {
   9473   struct mips_htab_traverse_info *hti = data;
   9474   struct mips_elf_link_hash_table *htab;
   9475   struct bfd_link_info *info;
   9476   bfd *output_bfd;
   9477 
   9478   info = hti->info;
   9479   output_bfd = hti->output_bfd;
   9480   htab = mips_elf_hash_table (info);
   9481   BFD_ASSERT (htab != NULL);
   9482 
   9483   if (h->needs_lazy_stub)
   9484     {
   9485       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
   9486       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
   9487       bfd_vma isa_bit = micromips_p;
   9488 
   9489       BFD_ASSERT (htab->root.dynobj != NULL);
   9490       if (h->root.plt.plist == NULL)
   9491 	h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner);
   9492       if (h->root.plt.plist == NULL)
   9493 	{
   9494 	  hti->error = TRUE;
   9495 	  return FALSE;
   9496 	}
   9497       h->root.root.u.def.section = htab->sstubs;
   9498       h->root.root.u.def.value = htab->sstubs->size + isa_bit;
   9499       h->root.plt.plist->stub_offset = htab->sstubs->size;
   9500       h->root.other = other;
   9501       htab->sstubs->size += htab->function_stub_size;
   9502     }
   9503   return TRUE;
   9504 }
   9505 
   9506 /* Allocate offsets in the stubs section to each symbol that needs one.
   9507    Set the final size of the .MIPS.stub section.  */
   9508 
   9509 static bfd_boolean
   9510 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
   9511 {
   9512   bfd *output_bfd = info->output_bfd;
   9513   bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
   9514   unsigned int other = micromips_p ? STO_MICROMIPS : 0;
   9515   bfd_vma isa_bit = micromips_p;
   9516   struct mips_elf_link_hash_table *htab;
   9517   struct mips_htab_traverse_info hti;
   9518   struct elf_link_hash_entry *h;
   9519   bfd *dynobj;
   9520 
   9521   htab = mips_elf_hash_table (info);
   9522   BFD_ASSERT (htab != NULL);
   9523 
   9524   if (htab->lazy_stub_count == 0)
   9525     return TRUE;
   9526 
   9527   htab->sstubs->size = 0;
   9528   hti.info = info;
   9529   hti.output_bfd = output_bfd;
   9530   hti.error = FALSE;
   9531   mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti);
   9532   if (hti.error)
   9533     return FALSE;
   9534   htab->sstubs->size += htab->function_stub_size;
   9535   BFD_ASSERT (htab->sstubs->size
   9536 	      == htab->lazy_stub_count * htab->function_stub_size);
   9537 
   9538   dynobj = elf_hash_table (info)->dynobj;
   9539   BFD_ASSERT (dynobj != NULL);
   9540   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_");
   9541   if (h == NULL)
   9542     return FALSE;
   9543   h->root.u.def.value = isa_bit;
   9544   h->other = other;
   9545   h->type = STT_FUNC;
   9546 
   9547   return TRUE;
   9548 }
   9549 
   9550 /* A mips_elf_link_hash_traverse callback for which DATA points to a
   9551    bfd_link_info.  If H uses the address of a PLT entry as the value
   9552    of the symbol, then set the entry in the symbol table now.  Prefer
   9553    a standard MIPS PLT entry.  */
   9554 
   9555 static bfd_boolean
   9556 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data)
   9557 {
   9558   struct bfd_link_info *info = data;
   9559   bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
   9560   struct mips_elf_link_hash_table *htab;
   9561   unsigned int other;
   9562   bfd_vma isa_bit;
   9563   bfd_vma val;
   9564 
   9565   htab = mips_elf_hash_table (info);
   9566   BFD_ASSERT (htab != NULL);
   9567 
   9568   if (h->use_plt_entry)
   9569     {
   9570       BFD_ASSERT (h->root.plt.plist != NULL);
   9571       BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE
   9572 		  || h->root.plt.plist->comp_offset != MINUS_ONE);
   9573 
   9574       val = htab->plt_header_size;
   9575       if (h->root.plt.plist->mips_offset != MINUS_ONE)
   9576 	{
   9577 	  isa_bit = 0;
   9578 	  val += h->root.plt.plist->mips_offset;
   9579 	  other = 0;
   9580 	}
   9581       else
   9582 	{
   9583 	  isa_bit = 1;
   9584 	  val += htab->plt_mips_offset + h->root.plt.plist->comp_offset;
   9585 	  other = micromips_p ? STO_MICROMIPS : STO_MIPS16;
   9586 	}
   9587       val += isa_bit;
   9588       /* For VxWorks, point at the PLT load stub rather than the lazy
   9589          resolution stub; this stub will become the canonical function
   9590          address.  */
   9591       if (htab->is_vxworks)
   9592 	val += 8;
   9593 
   9594       h->root.root.u.def.section = htab->splt;
   9595       h->root.root.u.def.value = val;
   9596       h->root.other = other;
   9597     }
   9598 
   9599   return TRUE;
   9600 }
   9601 
   9602 /* Set the sizes of the dynamic sections.  */
   9603 
   9604 bfd_boolean
   9605 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
   9606 				     struct bfd_link_info *info)
   9607 {
   9608   bfd *dynobj;
   9609   asection *s, *sreldyn;
   9610   bfd_boolean reltext;
   9611   struct mips_elf_link_hash_table *htab;
   9612 
   9613   htab = mips_elf_hash_table (info);
   9614   BFD_ASSERT (htab != NULL);
   9615   dynobj = elf_hash_table (info)->dynobj;
   9616   BFD_ASSERT (dynobj != NULL);
   9617 
   9618   if (elf_hash_table (info)->dynamic_sections_created)
   9619     {
   9620       /* Set the contents of the .interp section to the interpreter.  */
   9621       if (info->executable)
   9622 	{
   9623 	  s = bfd_get_linker_section (dynobj, ".interp");
   9624 	  BFD_ASSERT (s != NULL);
   9625 	  s->size
   9626 	    = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
   9627 	  s->contents
   9628 	    = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
   9629 	}
   9630 
   9631       /* Figure out the size of the PLT header if we know that we
   9632          are using it.  For the sake of cache alignment always use
   9633          a standard header whenever any standard entries are present
   9634          even if microMIPS entries are present as well.  This also
   9635          lets the microMIPS header rely on the value of $v0 only set
   9636          by microMIPS entries, for a small size reduction.
   9637 
   9638          Set symbol table entry values for symbols that use the
   9639          address of their PLT entry now that we can calculate it.
   9640 
   9641          Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
   9642          haven't already in _bfd_elf_create_dynamic_sections.  */
   9643       if (htab->splt && htab->plt_mips_offset + htab->plt_comp_offset != 0)
   9644 	{
   9645 	  bfd_boolean micromips_p = (MICROMIPS_P (output_bfd)
   9646 				     && !htab->plt_mips_offset);
   9647 	  unsigned int other = micromips_p ? STO_MICROMIPS : 0;
   9648 	  bfd_vma isa_bit = micromips_p;
   9649 	  struct elf_link_hash_entry *h;
   9650 	  bfd_vma size;
   9651 
   9652 	  BFD_ASSERT (htab->use_plts_and_copy_relocs);
   9653 	  BFD_ASSERT (htab->sgotplt->size == 0);
   9654 	  BFD_ASSERT (htab->splt->size == 0);
   9655 
   9656 	  if (htab->is_vxworks && info->shared)
   9657 	    size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
   9658 	  else if (htab->is_vxworks)
   9659 	    size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
   9660 	  else if (ABI_64_P (output_bfd))
   9661 	    size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry);
   9662 	  else if (ABI_N32_P (output_bfd))
   9663 	    size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry);
   9664 	  else if (!micromips_p)
   9665 	    size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
   9666 	  else if (htab->insn32)
   9667 	    size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
   9668 	  else
   9669 	    size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
   9670 
   9671 	  htab->plt_header_is_comp = micromips_p;
   9672 	  htab->plt_header_size = size;
   9673 	  htab->splt->size = (size
   9674 			      + htab->plt_mips_offset
   9675 			      + htab->plt_comp_offset);
   9676 	  htab->sgotplt->size = (htab->plt_got_index
   9677 				 * MIPS_ELF_GOT_SIZE (dynobj));
   9678 
   9679 	  mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info);
   9680 
   9681 	  if (htab->root.hplt == NULL)
   9682 	    {
   9683 	      h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
   9684 					       "_PROCEDURE_LINKAGE_TABLE_");
   9685 	      htab->root.hplt = h;
   9686 	      if (h == NULL)
   9687 		return FALSE;
   9688 	    }
   9689 
   9690 	  h = htab->root.hplt;
   9691 	  h->root.u.def.value = isa_bit;
   9692 	  h->other = other;
   9693 	  h->type = STT_FUNC;
   9694 	}
   9695     }
   9696 
   9697   /* Allocate space for global sym dynamic relocs.  */
   9698   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
   9699 
   9700   mips_elf_estimate_stub_size (output_bfd, info);
   9701 
   9702   if (!mips_elf_lay_out_got (output_bfd, info))
   9703     return FALSE;
   9704 
   9705   mips_elf_lay_out_lazy_stubs (info);
   9706 
   9707   /* The check_relocs and adjust_dynamic_symbol entry points have
   9708      determined the sizes of the various dynamic sections.  Allocate
   9709      memory for them.  */
   9710   reltext = FALSE;
   9711   for (s = dynobj->sections; s != NULL; s = s->next)
   9712     {
   9713       const char *name;
   9714 
   9715       /* It's OK to base decisions on the section name, because none
   9716 	 of the dynobj section names depend upon the input files.  */
   9717       name = bfd_get_section_name (dynobj, s);
   9718 
   9719       if ((s->flags & SEC_LINKER_CREATED) == 0)
   9720 	continue;
   9721 
   9722       if (CONST_STRNEQ (name, ".rel"))
   9723 	{
   9724 	  if (s->size != 0)
   9725 	    {
   9726 	      const char *outname;
   9727 	      asection *target;
   9728 
   9729 	      /* If this relocation section applies to a read only
   9730                  section, then we probably need a DT_TEXTREL entry.
   9731                  If the relocation section is .rel(a).dyn, we always
   9732                  assert a DT_TEXTREL entry rather than testing whether
   9733                  there exists a relocation to a read only section or
   9734                  not.  */
   9735 	      outname = bfd_get_section_name (output_bfd,
   9736 					      s->output_section);
   9737 	      target = bfd_get_section_by_name (output_bfd, outname + 4);
   9738 	      if ((target != NULL
   9739 		   && (target->flags & SEC_READONLY) != 0
   9740 		   && (target->flags & SEC_ALLOC) != 0)
   9741 		  || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
   9742 		reltext = TRUE;
   9743 
   9744 	      /* We use the reloc_count field as a counter if we need
   9745 		 to copy relocs into the output file.  */
   9746 	      if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
   9747 		s->reloc_count = 0;
   9748 
   9749 	      /* If combreloc is enabled, elf_link_sort_relocs() will
   9750 		 sort relocations, but in a different way than we do,
   9751 		 and before we're done creating relocations.  Also, it
   9752 		 will move them around between input sections'
   9753 		 relocation's contents, so our sorting would be
   9754 		 broken, so don't let it run.  */
   9755 	      info->combreloc = 0;
   9756 	    }
   9757 	}
   9758       else if (info->executable
   9759 	       && ! mips_elf_hash_table (info)->use_rld_obj_head
   9760 	       && CONST_STRNEQ (name, ".rld_map"))
   9761 	{
   9762 	  /* We add a room for __rld_map.  It will be filled in by the
   9763 	     rtld to contain a pointer to the _r_debug structure.  */
   9764 	  s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
   9765 	}
   9766       else if (SGI_COMPAT (output_bfd)
   9767 	       && CONST_STRNEQ (name, ".compact_rel"))
   9768 	s->size += mips_elf_hash_table (info)->compact_rel_size;
   9769       else if (s == htab->splt)
   9770 	{
   9771 	  /* If the last PLT entry has a branch delay slot, allocate
   9772 	     room for an extra nop to fill the delay slot.  This is
   9773 	     for CPUs without load interlocking.  */
   9774 	  if (! LOAD_INTERLOCKS_P (output_bfd)
   9775 	      && ! htab->is_vxworks && s->size > 0)
   9776 	    s->size += 4;
   9777 	}
   9778       else if (! CONST_STRNEQ (name, ".init")
   9779 	       && s != htab->sgot
   9780 	       && s != htab->sgotplt
   9781 	       && s != htab->sstubs
   9782 	       && s != htab->sdynbss)
   9783 	{
   9784 	  /* It's not one of our sections, so don't allocate space.  */
   9785 	  continue;
   9786 	}
   9787 
   9788       if (s->size == 0)
   9789 	{
   9790 	  s->flags |= SEC_EXCLUDE;
   9791 	  continue;
   9792 	}
   9793 
   9794       if ((s->flags & SEC_HAS_CONTENTS) == 0)
   9795 	continue;
   9796 
   9797       /* Allocate memory for the section contents.  */
   9798       s->contents = bfd_zalloc (dynobj, s->size);
   9799       if (s->contents == NULL)
   9800 	{
   9801 	  bfd_set_error (bfd_error_no_memory);
   9802 	  return FALSE;
   9803 	}
   9804     }
   9805 
   9806   if (elf_hash_table (info)->dynamic_sections_created)
   9807     {
   9808       /* Add some entries to the .dynamic section.  We fill in the
   9809 	 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
   9810 	 must add the entries now so that we get the correct size for
   9811 	 the .dynamic section.  */
   9812 
   9813       /* SGI object has the equivalence of DT_DEBUG in the
   9814 	 DT_MIPS_RLD_MAP entry.  This must come first because glibc
   9815 	 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
   9816 	 may only look at the first one they see.  */
   9817       if (!info->shared
   9818 	  && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
   9819 	return FALSE;
   9820 
   9821       if (info->executable
   9822 	  && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0))
   9823 	return FALSE;
   9824 
   9825       /* The DT_DEBUG entry may be filled in by the dynamic linker and
   9826 	 used by the debugger.  */
   9827       if (info->executable
   9828 	  && !SGI_COMPAT (output_bfd)
   9829 	  && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
   9830 	return FALSE;
   9831 
   9832       if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
   9833 	info->flags |= DF_TEXTREL;
   9834 
   9835       if ((info->flags & DF_TEXTREL) != 0)
   9836 	{
   9837 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
   9838 	    return FALSE;
   9839 
   9840 	  /* Clear the DF_TEXTREL flag.  It will be set again if we
   9841 	     write out an actual text relocation; we may not, because
   9842 	     at this point we do not know whether e.g. any .eh_frame
   9843 	     absolute relocations have been converted to PC-relative.  */
   9844 	  info->flags &= ~DF_TEXTREL;
   9845 	}
   9846 
   9847       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
   9848 	return FALSE;
   9849 
   9850       sreldyn = mips_elf_rel_dyn_section (info, FALSE);
   9851       if (htab->is_vxworks)
   9852 	{
   9853 	  /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
   9854 	     use any of the DT_MIPS_* tags.  */
   9855 	  if (sreldyn && sreldyn->size > 0)
   9856 	    {
   9857 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
   9858 		return FALSE;
   9859 
   9860 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
   9861 		return FALSE;
   9862 
   9863 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
   9864 		return FALSE;
   9865 	    }
   9866 	}
   9867       else
   9868 	{
   9869 	  if (sreldyn && sreldyn->size > 0)
   9870 	    {
   9871 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
   9872 		return FALSE;
   9873 
   9874 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
   9875 		return FALSE;
   9876 
   9877 	      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
   9878 		return FALSE;
   9879 	    }
   9880 
   9881 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
   9882 	    return FALSE;
   9883 
   9884 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
   9885 	    return FALSE;
   9886 
   9887 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
   9888 	    return FALSE;
   9889 
   9890 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
   9891 	    return FALSE;
   9892 
   9893 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
   9894 	    return FALSE;
   9895 
   9896 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
   9897 	    return FALSE;
   9898 
   9899 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
   9900 	    return FALSE;
   9901 
   9902 	  if (IRIX_COMPAT (dynobj) == ict_irix5
   9903 	      && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
   9904 	    return FALSE;
   9905 
   9906 	  if (IRIX_COMPAT (dynobj) == ict_irix6
   9907 	      && (bfd_get_section_by_name
   9908 		  (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
   9909 	      && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
   9910 	    return FALSE;
   9911 	}
   9912       if (htab->splt->size > 0)
   9913 	{
   9914 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
   9915 	    return FALSE;
   9916 
   9917 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
   9918 	    return FALSE;
   9919 
   9920 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
   9921 	    return FALSE;
   9922 
   9923 	  if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
   9924 	    return FALSE;
   9925 	}
   9926       if (htab->is_vxworks
   9927 	  && !elf_vxworks_add_dynamic_entries (output_bfd, info))
   9928 	return FALSE;
   9929     }
   9930 
   9931   return TRUE;
   9932 }
   9933 
   9934 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
   9936    Adjust its R_ADDEND field so that it is correct for the output file.
   9937    LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
   9938    and sections respectively; both use symbol indexes.  */
   9939 
   9940 static void
   9941 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
   9942 			bfd *input_bfd, Elf_Internal_Sym *local_syms,
   9943 			asection **local_sections, Elf_Internal_Rela *rel)
   9944 {
   9945   unsigned int r_type, r_symndx;
   9946   Elf_Internal_Sym *sym;
   9947   asection *sec;
   9948 
   9949   if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
   9950     {
   9951       r_type = ELF_R_TYPE (output_bfd, rel->r_info);
   9952       if (gprel16_reloc_p (r_type)
   9953 	  || r_type == R_MIPS_GPREL32
   9954 	  || literal_reloc_p (r_type))
   9955 	{
   9956 	  rel->r_addend += _bfd_get_gp_value (input_bfd);
   9957 	  rel->r_addend -= _bfd_get_gp_value (output_bfd);
   9958 	}
   9959 
   9960       r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
   9961       sym = local_syms + r_symndx;
   9962 
   9963       /* Adjust REL's addend to account for section merging.  */
   9964       if (!info->relocatable)
   9965 	{
   9966 	  sec = local_sections[r_symndx];
   9967 	  _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
   9968 	}
   9969 
   9970       /* This would normally be done by the rela_normal code in elflink.c.  */
   9971       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
   9972 	rel->r_addend += local_sections[r_symndx]->output_offset;
   9973     }
   9974 }
   9975 
   9976 /* Handle relocations against symbols from removed linkonce sections,
   9977    or sections discarded by a linker script.  We use this wrapper around
   9978    RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
   9979    on 64-bit ELF targets.  In this case for any relocation handled, which
   9980    always be the first in a triplet, the remaining two have to be processed
   9981    together with the first, even if they are R_MIPS_NONE.  It is the symbol
   9982    index referred by the first reloc that applies to all the three and the
   9983    remaining two never refer to an object symbol.  And it is the final
   9984    relocation (the last non-null one) that determines the output field of
   9985    the whole relocation so retrieve the corresponding howto structure for
   9986    the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
   9987 
   9988    Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
   9989    and therefore requires to be pasted in a loop.  It also defines a block
   9990    and does not protect any of its arguments, hence the extra brackets.  */
   9991 
   9992 static void
   9993 mips_reloc_against_discarded_section (bfd *output_bfd,
   9994 				      struct bfd_link_info *info,
   9995 				      bfd *input_bfd, asection *input_section,
   9996 				      Elf_Internal_Rela **rel,
   9997 				      const Elf_Internal_Rela **relend,
   9998 				      bfd_boolean rel_reloc,
   9999 				      reloc_howto_type *howto,
   10000 				      bfd_byte *contents)
   10001 {
   10002   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
   10003   int count = bed->s->int_rels_per_ext_rel;
   10004   unsigned int r_type;
   10005   int i;
   10006 
   10007   for (i = count - 1; i > 0; i--)
   10008     {
   10009       r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
   10010       if (r_type != R_MIPS_NONE)
   10011 	{
   10012 	  howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
   10013 	  break;
   10014 	}
   10015     }
   10016   do
   10017     {
   10018        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
   10019 					(*rel), count, (*relend),
   10020 					howto, i, contents);
   10021     }
   10022   while (0);
   10023 }
   10024 
   10025 /* Relocate a MIPS ELF section.  */
   10026 
   10027 bfd_boolean
   10028 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
   10029 				bfd *input_bfd, asection *input_section,
   10030 				bfd_byte *contents, Elf_Internal_Rela *relocs,
   10031 				Elf_Internal_Sym *local_syms,
   10032 				asection **local_sections)
   10033 {
   10034   Elf_Internal_Rela *rel;
   10035   const Elf_Internal_Rela *relend;
   10036   bfd_vma addend = 0;
   10037   bfd_boolean use_saved_addend_p = FALSE;
   10038   const struct elf_backend_data *bed;
   10039 
   10040   bed = get_elf_backend_data (output_bfd);
   10041   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
   10042   for (rel = relocs; rel < relend; ++rel)
   10043     {
   10044       const char *name;
   10045       bfd_vma value = 0;
   10046       reloc_howto_type *howto;
   10047       bfd_boolean cross_mode_jump_p = FALSE;
   10048       /* TRUE if the relocation is a RELA relocation, rather than a
   10049          REL relocation.  */
   10050       bfd_boolean rela_relocation_p = TRUE;
   10051       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
   10052       const char *msg;
   10053       unsigned long r_symndx;
   10054       asection *sec;
   10055       Elf_Internal_Shdr *symtab_hdr;
   10056       struct elf_link_hash_entry *h;
   10057       bfd_boolean rel_reloc;
   10058 
   10059       rel_reloc = (NEWABI_P (input_bfd)
   10060 		   && mips_elf_rel_relocation_p (input_bfd, input_section,
   10061 						 relocs, rel));
   10062       /* Find the relocation howto for this relocation.  */
   10063       howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
   10064 
   10065       r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
   10066       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   10067       if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
   10068 	{
   10069 	  sec = local_sections[r_symndx];
   10070 	  h = NULL;
   10071 	}
   10072       else
   10073 	{
   10074 	  unsigned long extsymoff;
   10075 
   10076 	  extsymoff = 0;
   10077 	  if (!elf_bad_symtab (input_bfd))
   10078 	    extsymoff = symtab_hdr->sh_info;
   10079 	  h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
   10080 	  while (h->root.type == bfd_link_hash_indirect
   10081 		 || h->root.type == bfd_link_hash_warning)
   10082 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
   10083 
   10084 	  sec = NULL;
   10085 	  if (h->root.type == bfd_link_hash_defined
   10086 	      || h->root.type == bfd_link_hash_defweak)
   10087 	    sec = h->root.u.def.section;
   10088 	}
   10089 
   10090       if (sec != NULL && discarded_section (sec))
   10091 	{
   10092 	  mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
   10093 						input_section, &rel, &relend,
   10094 						rel_reloc, howto, contents);
   10095 	  continue;
   10096 	}
   10097 
   10098       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
   10099 	{
   10100 	  /* Some 32-bit code uses R_MIPS_64.  In particular, people use
   10101 	     64-bit code, but make sure all their addresses are in the
   10102 	     lowermost or uppermost 32-bit section of the 64-bit address
   10103 	     space.  Thus, when they use an R_MIPS_64 they mean what is
   10104 	     usually meant by R_MIPS_32, with the exception that the
   10105 	     stored value is sign-extended to 64 bits.  */
   10106 	  howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
   10107 
   10108 	  /* On big-endian systems, we need to lie about the position
   10109 	     of the reloc.  */
   10110 	  if (bfd_big_endian (input_bfd))
   10111 	    rel->r_offset += 4;
   10112 	}
   10113 
   10114       if (!use_saved_addend_p)
   10115 	{
   10116 	  /* If these relocations were originally of the REL variety,
   10117 	     we must pull the addend out of the field that will be
   10118 	     relocated.  Otherwise, we simply use the contents of the
   10119 	     RELA relocation.  */
   10120 	  if (mips_elf_rel_relocation_p (input_bfd, input_section,
   10121 					 relocs, rel))
   10122 	    {
   10123 	      rela_relocation_p = FALSE;
   10124 	      addend = mips_elf_read_rel_addend (input_bfd, rel,
   10125 						 howto, contents);
   10126 	      if (hi16_reloc_p (r_type)
   10127 		  || (got16_reloc_p (r_type)
   10128 		      && mips_elf_local_relocation_p (input_bfd, rel,
   10129 						      local_sections)))
   10130 		{
   10131 		  if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
   10132 						     contents, &addend))
   10133 		    {
   10134 		      if (h)
   10135 			name = h->root.root.string;
   10136 		      else
   10137 			name = bfd_elf_sym_name (input_bfd, symtab_hdr,
   10138 						 local_syms + r_symndx,
   10139 						 sec);
   10140 		      (*_bfd_error_handler)
   10141 			(_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
   10142 			 input_bfd, input_section, name, howto->name,
   10143 			 rel->r_offset);
   10144 		    }
   10145 		}
   10146 	      else
   10147 		addend <<= howto->rightshift;
   10148 	    }
   10149 	  else
   10150 	    addend = rel->r_addend;
   10151 	  mips_elf_adjust_addend (output_bfd, info, input_bfd,
   10152 				  local_syms, local_sections, rel);
   10153 	}
   10154 
   10155       if (info->relocatable)
   10156 	{
   10157 	  if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
   10158 	      && bfd_big_endian (input_bfd))
   10159 	    rel->r_offset -= 4;
   10160 
   10161 	  if (!rela_relocation_p && rel->r_addend)
   10162 	    {
   10163 	      addend += rel->r_addend;
   10164 	      if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
   10165 		addend = mips_elf_high (addend);
   10166 	      else if (r_type == R_MIPS_HIGHER)
   10167 		addend = mips_elf_higher (addend);
   10168 	      else if (r_type == R_MIPS_HIGHEST)
   10169 		addend = mips_elf_highest (addend);
   10170 	      else
   10171 		addend >>= howto->rightshift;
   10172 
   10173 	      /* We use the source mask, rather than the destination
   10174 		 mask because the place to which we are writing will be
   10175 		 source of the addend in the final link.  */
   10176 	      addend &= howto->src_mask;
   10177 
   10178 	      if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
   10179 		/* See the comment above about using R_MIPS_64 in the 32-bit
   10180 		   ABI.  Here, we need to update the addend.  It would be
   10181 		   possible to get away with just using the R_MIPS_32 reloc
   10182 		   but for endianness.  */
   10183 		{
   10184 		  bfd_vma sign_bits;
   10185 		  bfd_vma low_bits;
   10186 		  bfd_vma high_bits;
   10187 
   10188 		  if (addend & ((bfd_vma) 1 << 31))
   10189 #ifdef BFD64
   10190 		    sign_bits = ((bfd_vma) 1 << 32) - 1;
   10191 #else
   10192 		    sign_bits = -1;
   10193 #endif
   10194 		  else
   10195 		    sign_bits = 0;
   10196 
   10197 		  /* If we don't know that we have a 64-bit type,
   10198 		     do two separate stores.  */
   10199 		  if (bfd_big_endian (input_bfd))
   10200 		    {
   10201 		      /* Store the sign-bits (which are most significant)
   10202 			 first.  */
   10203 		      low_bits = sign_bits;
   10204 		      high_bits = addend;
   10205 		    }
   10206 		  else
   10207 		    {
   10208 		      low_bits = addend;
   10209 		      high_bits = sign_bits;
   10210 		    }
   10211 		  bfd_put_32 (input_bfd, low_bits,
   10212 			      contents + rel->r_offset);
   10213 		  bfd_put_32 (input_bfd, high_bits,
   10214 			      contents + rel->r_offset + 4);
   10215 		  continue;
   10216 		}
   10217 
   10218 	      if (! mips_elf_perform_relocation (info, howto, rel, addend,
   10219 						 input_bfd, input_section,
   10220 						 contents, FALSE))
   10221 		return FALSE;
   10222 	    }
   10223 
   10224 	  /* Go on to the next relocation.  */
   10225 	  continue;
   10226 	}
   10227 
   10228       /* In the N32 and 64-bit ABIs there may be multiple consecutive
   10229 	 relocations for the same offset.  In that case we are
   10230 	 supposed to treat the output of each relocation as the addend
   10231 	 for the next.  */
   10232       if (rel + 1 < relend
   10233 	  && rel->r_offset == rel[1].r_offset
   10234 	  && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
   10235 	use_saved_addend_p = TRUE;
   10236       else
   10237 	use_saved_addend_p = FALSE;
   10238 
   10239       /* Figure out what value we are supposed to relocate.  */
   10240       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
   10241 					     input_section, info, rel,
   10242 					     addend, howto, local_syms,
   10243 					     local_sections, &value,
   10244 					     &name, &cross_mode_jump_p,
   10245 					     use_saved_addend_p))
   10246 	{
   10247 	case bfd_reloc_continue:
   10248 	  /* There's nothing to do.  */
   10249 	  continue;
   10250 
   10251 	case bfd_reloc_undefined:
   10252 	  /* mips_elf_calculate_relocation already called the
   10253 	     undefined_symbol callback.  There's no real point in
   10254 	     trying to perform the relocation at this point, so we
   10255 	     just skip ahead to the next relocation.  */
   10256 	  continue;
   10257 
   10258 	case bfd_reloc_notsupported:
   10259 	  msg = _("internal error: unsupported relocation error");
   10260 	  info->callbacks->warning
   10261 	    (info, msg, name, input_bfd, input_section, rel->r_offset);
   10262 	  return FALSE;
   10263 
   10264 	case bfd_reloc_overflow:
   10265 	  if (use_saved_addend_p)
   10266 	    /* Ignore overflow until we reach the last relocation for
   10267 	       a given location.  */
   10268 	    ;
   10269 	  else
   10270 	    {
   10271 	      struct mips_elf_link_hash_table *htab;
   10272 
   10273 	      htab = mips_elf_hash_table (info);
   10274 	      BFD_ASSERT (htab != NULL);
   10275 	      BFD_ASSERT (name != NULL);
   10276 	      if (!htab->small_data_overflow_reported
   10277 		  && (gprel16_reloc_p (howto->type)
   10278 		      || literal_reloc_p (howto->type)))
   10279 		{
   10280 		  msg = _("small-data section exceeds 64KB;"
   10281 			  " lower small-data size limit (see option -G)");
   10282 
   10283 		  htab->small_data_overflow_reported = TRUE;
   10284 		  (*info->callbacks->einfo) ("%P: %s\n", msg);
   10285 		}
   10286 	      if (! ((*info->callbacks->reloc_overflow)
   10287 		     (info, NULL, name, howto->name, (bfd_vma) 0,
   10288 		      input_bfd, input_section, rel->r_offset)))
   10289 		return FALSE;
   10290 	    }
   10291 	  break;
   10292 
   10293 	case bfd_reloc_ok:
   10294 	  break;
   10295 
   10296 	case bfd_reloc_outofrange:
   10297 	  if (jal_reloc_p (howto->type))
   10298 	    {
   10299 	      msg = _("JALX to a non-word-aligned address");
   10300 	      info->callbacks->warning
   10301 		(info, msg, name, input_bfd, input_section, rel->r_offset);
   10302 	      return FALSE;
   10303 	    }
   10304 	  if (aligned_pcrel_reloc_p (howto->type))
   10305 	    {
   10306 	      msg = _("PC-relative load from unaligned address");
   10307 	      info->callbacks->warning
   10308 		(info, msg, name, input_bfd, input_section, rel->r_offset);
   10309 	      return FALSE;
   10310 	    }
   10311 	  /* Fall through.  */
   10312 
   10313 	default:
   10314 	  abort ();
   10315 	  break;
   10316 	}
   10317 
   10318       /* If we've got another relocation for the address, keep going
   10319 	 until we reach the last one.  */
   10320       if (use_saved_addend_p)
   10321 	{
   10322 	  addend = value;
   10323 	  continue;
   10324 	}
   10325 
   10326       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
   10327 	/* See the comment above about using R_MIPS_64 in the 32-bit
   10328 	   ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
   10329 	   that calculated the right value.  Now, however, we
   10330 	   sign-extend the 32-bit result to 64-bits, and store it as a
   10331 	   64-bit value.  We are especially generous here in that we
   10332 	   go to extreme lengths to support this usage on systems with
   10333 	   only a 32-bit VMA.  */
   10334 	{
   10335 	  bfd_vma sign_bits;
   10336 	  bfd_vma low_bits;
   10337 	  bfd_vma high_bits;
   10338 
   10339 	  if (value & ((bfd_vma) 1 << 31))
   10340 #ifdef BFD64
   10341 	    sign_bits = ((bfd_vma) 1 << 32) - 1;
   10342 #else
   10343 	    sign_bits = -1;
   10344 #endif
   10345 	  else
   10346 	    sign_bits = 0;
   10347 
   10348 	  /* If we don't know that we have a 64-bit type,
   10349 	     do two separate stores.  */
   10350 	  if (bfd_big_endian (input_bfd))
   10351 	    {
   10352 	      /* Undo what we did above.  */
   10353 	      rel->r_offset -= 4;
   10354 	      /* Store the sign-bits (which are most significant)
   10355 		 first.  */
   10356 	      low_bits = sign_bits;
   10357 	      high_bits = value;
   10358 	    }
   10359 	  else
   10360 	    {
   10361 	      low_bits = value;
   10362 	      high_bits = sign_bits;
   10363 	    }
   10364 	  bfd_put_32 (input_bfd, low_bits,
   10365 		      contents + rel->r_offset);
   10366 	  bfd_put_32 (input_bfd, high_bits,
   10367 		      contents + rel->r_offset + 4);
   10368 	  continue;
   10369 	}
   10370 
   10371       /* Actually perform the relocation.  */
   10372       if (! mips_elf_perform_relocation (info, howto, rel, value,
   10373 					 input_bfd, input_section,
   10374 					 contents, cross_mode_jump_p))
   10375 	return FALSE;
   10376     }
   10377 
   10378   return TRUE;
   10379 }
   10380 
   10381 /* A function that iterates over each entry in la25_stubs and fills
   10383    in the code for each one.  DATA points to a mips_htab_traverse_info.  */
   10384 
   10385 static int
   10386 mips_elf_create_la25_stub (void **slot, void *data)
   10387 {
   10388   struct mips_htab_traverse_info *hti;
   10389   struct mips_elf_link_hash_table *htab;
   10390   struct mips_elf_la25_stub *stub;
   10391   asection *s;
   10392   bfd_byte *loc;
   10393   bfd_vma offset, target, target_high, target_low;
   10394 
   10395   stub = (struct mips_elf_la25_stub *) *slot;
   10396   hti = (struct mips_htab_traverse_info *) data;
   10397   htab = mips_elf_hash_table (hti->info);
   10398   BFD_ASSERT (htab != NULL);
   10399 
   10400   /* Create the section contents, if we haven't already.  */
   10401   s = stub->stub_section;
   10402   loc = s->contents;
   10403   if (loc == NULL)
   10404     {
   10405       loc = bfd_malloc (s->size);
   10406       if (loc == NULL)
   10407 	{
   10408 	  hti->error = TRUE;
   10409 	  return FALSE;
   10410 	}
   10411       s->contents = loc;
   10412     }
   10413 
   10414   /* Work out where in the section this stub should go.  */
   10415   offset = stub->offset;
   10416 
   10417   /* Work out the target address.  */
   10418   target = mips_elf_get_la25_target (stub, &s);
   10419   target += s->output_section->vma + s->output_offset;
   10420 
   10421   target_high = ((target + 0x8000) >> 16) & 0xffff;
   10422   target_low = (target & 0xffff);
   10423 
   10424   if (stub->stub_section != htab->strampoline)
   10425     {
   10426       /* This is a simple LUI/ADDIU stub.  Zero out the beginning
   10427 	 of the section and write the two instructions at the end.  */
   10428       memset (loc, 0, offset);
   10429       loc += offset;
   10430       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
   10431 	{
   10432 	  bfd_put_micromips_32 (hti->output_bfd,
   10433 				LA25_LUI_MICROMIPS (target_high),
   10434 				loc);
   10435 	  bfd_put_micromips_32 (hti->output_bfd,
   10436 				LA25_ADDIU_MICROMIPS (target_low),
   10437 				loc + 4);
   10438 	}
   10439       else
   10440 	{
   10441 	  bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
   10442 	  bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
   10443 	}
   10444     }
   10445   else
   10446     {
   10447       /* This is trampoline.  */
   10448       loc += offset;
   10449       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
   10450 	{
   10451 	  bfd_put_micromips_32 (hti->output_bfd,
   10452 				LA25_LUI_MICROMIPS (target_high), loc);
   10453 	  bfd_put_micromips_32 (hti->output_bfd,
   10454 				LA25_J_MICROMIPS (target), loc + 4);
   10455 	  bfd_put_micromips_32 (hti->output_bfd,
   10456 				LA25_ADDIU_MICROMIPS (target_low), loc + 8);
   10457 	  bfd_put_32 (hti->output_bfd, 0, loc + 12);
   10458 	}
   10459       else
   10460 	{
   10461 	  bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
   10462 	  bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
   10463 	  bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
   10464 	  bfd_put_32 (hti->output_bfd, 0, loc + 12);
   10465 	}
   10466     }
   10467   return TRUE;
   10468 }
   10469 
   10470 /* If NAME is one of the special IRIX6 symbols defined by the linker,
   10471    adjust it appropriately now.  */
   10472 
   10473 static void
   10474 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
   10475 				      const char *name, Elf_Internal_Sym *sym)
   10476 {
   10477   /* The linker script takes care of providing names and values for
   10478      these, but we must place them into the right sections.  */
   10479   static const char* const text_section_symbols[] = {
   10480     "_ftext",
   10481     "_etext",
   10482     "__dso_displacement",
   10483     "__elf_header",
   10484     "__program_header_table",
   10485     NULL
   10486   };
   10487 
   10488   static const char* const data_section_symbols[] = {
   10489     "_fdata",
   10490     "_edata",
   10491     "_end",
   10492     "_fbss",
   10493     NULL
   10494   };
   10495 
   10496   const char* const *p;
   10497   int i;
   10498 
   10499   for (i = 0; i < 2; ++i)
   10500     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
   10501 	 *p;
   10502 	 ++p)
   10503       if (strcmp (*p, name) == 0)
   10504 	{
   10505 	  /* All of these symbols are given type STT_SECTION by the
   10506 	     IRIX6 linker.  */
   10507 	  sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
   10508 	  sym->st_other = STO_PROTECTED;
   10509 
   10510 	  /* The IRIX linker puts these symbols in special sections.  */
   10511 	  if (i == 0)
   10512 	    sym->st_shndx = SHN_MIPS_TEXT;
   10513 	  else
   10514 	    sym->st_shndx = SHN_MIPS_DATA;
   10515 
   10516 	  break;
   10517 	}
   10518 }
   10519 
   10520 /* Finish up dynamic symbol handling.  We set the contents of various
   10521    dynamic sections here.  */
   10522 
   10523 bfd_boolean
   10524 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
   10525 				     struct bfd_link_info *info,
   10526 				     struct elf_link_hash_entry *h,
   10527 				     Elf_Internal_Sym *sym)
   10528 {
   10529   bfd *dynobj;
   10530   asection *sgot;
   10531   struct mips_got_info *g, *gg;
   10532   const char *name;
   10533   int idx;
   10534   struct mips_elf_link_hash_table *htab;
   10535   struct mips_elf_link_hash_entry *hmips;
   10536 
   10537   htab = mips_elf_hash_table (info);
   10538   BFD_ASSERT (htab != NULL);
   10539   dynobj = elf_hash_table (info)->dynobj;
   10540   hmips = (struct mips_elf_link_hash_entry *) h;
   10541 
   10542   BFD_ASSERT (!htab->is_vxworks);
   10543 
   10544   if (h->plt.plist != NULL
   10545       && (h->plt.plist->mips_offset != MINUS_ONE
   10546 	  || h->plt.plist->comp_offset != MINUS_ONE))
   10547     {
   10548       /* We've decided to create a PLT entry for this symbol.  */
   10549       bfd_byte *loc;
   10550       bfd_vma header_address, got_address;
   10551       bfd_vma got_address_high, got_address_low, load;
   10552       bfd_vma got_index;
   10553       bfd_vma isa_bit;
   10554 
   10555       got_index = h->plt.plist->gotplt_index;
   10556 
   10557       BFD_ASSERT (htab->use_plts_and_copy_relocs);
   10558       BFD_ASSERT (h->dynindx != -1);
   10559       BFD_ASSERT (htab->splt != NULL);
   10560       BFD_ASSERT (got_index != MINUS_ONE);
   10561       BFD_ASSERT (!h->def_regular);
   10562 
   10563       /* Calculate the address of the PLT header.  */
   10564       isa_bit = htab->plt_header_is_comp;
   10565       header_address = (htab->splt->output_section->vma
   10566 			+ htab->splt->output_offset + isa_bit);
   10567 
   10568       /* Calculate the address of the .got.plt entry.  */
   10569       got_address = (htab->sgotplt->output_section->vma
   10570 		     + htab->sgotplt->output_offset
   10571 		     + got_index * MIPS_ELF_GOT_SIZE (dynobj));
   10572 
   10573       got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
   10574       got_address_low = got_address & 0xffff;
   10575 
   10576       /* Initially point the .got.plt entry at the PLT header.  */
   10577       loc = (htab->sgotplt->contents + got_index * MIPS_ELF_GOT_SIZE (dynobj));
   10578       if (ABI_64_P (output_bfd))
   10579 	bfd_put_64 (output_bfd, header_address, loc);
   10580       else
   10581 	bfd_put_32 (output_bfd, header_address, loc);
   10582 
   10583       /* Now handle the PLT itself.  First the standard entry (the order
   10584          does not matter, we just have to pick one).  */
   10585       if (h->plt.plist->mips_offset != MINUS_ONE)
   10586 	{
   10587 	  const bfd_vma *plt_entry;
   10588 	  bfd_vma plt_offset;
   10589 
   10590 	  plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
   10591 
   10592 	  BFD_ASSERT (plt_offset <= htab->splt->size);
   10593 
   10594 	  /* Find out where the .plt entry should go.  */
   10595 	  loc = htab->splt->contents + plt_offset;
   10596 
   10597 	  /* Pick the load opcode.  */
   10598 	  load = MIPS_ELF_LOAD_WORD (output_bfd);
   10599 
   10600 	  /* Fill in the PLT entry itself.  */
   10601 
   10602 	  if (MIPSR6_P (output_bfd)
   10603 	      && mips_elf_hash_table (info)->compact_branches)
   10604 	    plt_entry = mipsr6_exec_plt_entry_compact;
   10605 	  else if (MIPSR6_P (output_bfd))
   10606 	    plt_entry = mipsr6_exec_plt_entry;
   10607 	  else
   10608 	    plt_entry = mips_exec_plt_entry;
   10609 	  bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
   10610 	  bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load,
   10611 		      loc + 4);
   10612 
   10613 	  if (! LOAD_INTERLOCKS_P (output_bfd) || MIPSR6_P (output_bfd))
   10614 	    {
   10615 	      bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
   10616 	      bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
   10617 	    }
   10618 	  else
   10619 	    {
   10620 	      bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
   10621 	      bfd_put_32 (output_bfd, plt_entry[2] | got_address_low,
   10622 			  loc + 12);
   10623 	    }
   10624 	}
   10625 
   10626       /* Now the compressed entry.  They come after any standard ones.  */
   10627       if (h->plt.plist->comp_offset != MINUS_ONE)
   10628 	{
   10629 	  bfd_vma plt_offset;
   10630 
   10631 	  plt_offset = (htab->plt_header_size + htab->plt_mips_offset
   10632 			+ h->plt.plist->comp_offset);
   10633 
   10634 	  BFD_ASSERT (plt_offset <= htab->splt->size);
   10635 
   10636 	  /* Find out where the .plt entry should go.  */
   10637 	  loc = htab->splt->contents + plt_offset;
   10638 
   10639 	  /* Fill in the PLT entry itself.  */
   10640 	  if (!MICROMIPS_P (output_bfd))
   10641 	    {
   10642 	      const bfd_vma *plt_entry = mips16_o32_exec_plt_entry;
   10643 
   10644 	      bfd_put_16 (output_bfd, plt_entry[0], loc);
   10645 	      bfd_put_16 (output_bfd, plt_entry[1], loc + 2);
   10646 	      bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
   10647 	      bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
   10648 	      bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
   10649 	      bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
   10650 	      bfd_put_32 (output_bfd, got_address, loc + 12);
   10651 	    }
   10652 	  else if (htab->insn32)
   10653 	    {
   10654 	      const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry;
   10655 
   10656 	      bfd_put_16 (output_bfd, plt_entry[0], loc);
   10657 	      bfd_put_16 (output_bfd, got_address_high, loc + 2);
   10658 	      bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
   10659 	      bfd_put_16 (output_bfd, got_address_low, loc + 6);
   10660 	      bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
   10661 	      bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
   10662 	      bfd_put_16 (output_bfd, plt_entry[6], loc + 12);
   10663 	      bfd_put_16 (output_bfd, got_address_low, loc + 14);
   10664 	    }
   10665 	  else
   10666 	    {
   10667 	      const bfd_vma *plt_entry = micromips_o32_exec_plt_entry;
   10668 	      bfd_signed_vma gotpc_offset;
   10669 	      bfd_vma loc_address;
   10670 
   10671 	      BFD_ASSERT (got_address % 4 == 0);
   10672 
   10673 	      loc_address = (htab->splt->output_section->vma
   10674 			     + htab->splt->output_offset + plt_offset);
   10675 	      gotpc_offset = got_address - ((loc_address | 3) ^ 3);
   10676 
   10677 	      /* ADDIUPC has a span of +/-16MB, check we're in range.  */
   10678 	      if (gotpc_offset + 0x1000000 >= 0x2000000)
   10679 		{
   10680 		  (*_bfd_error_handler)
   10681 		    (_("%B: `%A' offset of %ld from `%A' "
   10682 		       "beyond the range of ADDIUPC"),
   10683 		     output_bfd,
   10684 		     htab->sgotplt->output_section,
   10685 		     htab->splt->output_section,
   10686 		     (long) gotpc_offset);
   10687 		  bfd_set_error (bfd_error_no_error);
   10688 		  return FALSE;
   10689 		}
   10690 	      bfd_put_16 (output_bfd,
   10691 			  plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
   10692 	      bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
   10693 	      bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
   10694 	      bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
   10695 	      bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
   10696 	      bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
   10697 	    }
   10698 	}
   10699 
   10700       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
   10701       mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
   10702 					  got_index - 2, h->dynindx,
   10703 					  R_MIPS_JUMP_SLOT, got_address);
   10704 
   10705       /* We distinguish between PLT entries and lazy-binding stubs by
   10706 	 giving the former an st_other value of STO_MIPS_PLT.  Set the
   10707 	 flag and leave the value if there are any relocations in the
   10708 	 binary where pointer equality matters.  */
   10709       sym->st_shndx = SHN_UNDEF;
   10710       if (h->pointer_equality_needed)
   10711 	sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other);
   10712       else
   10713 	{
   10714 	  sym->st_value = 0;
   10715 	  sym->st_other = 0;
   10716 	}
   10717     }
   10718 
   10719   if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE)
   10720     {
   10721       /* We've decided to create a lazy-binding stub.  */
   10722       bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
   10723       unsigned int other = micromips_p ? STO_MICROMIPS : 0;
   10724       bfd_vma stub_size = htab->function_stub_size;
   10725       bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
   10726       bfd_vma isa_bit = micromips_p;
   10727       bfd_vma stub_big_size;
   10728 
   10729       if (!micromips_p)
   10730 	stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE;
   10731       else if (htab->insn32)
   10732 	stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE;
   10733       else
   10734 	stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE;
   10735 
   10736       /* This symbol has a stub.  Set it up.  */
   10737 
   10738       BFD_ASSERT (h->dynindx != -1);
   10739 
   10740       BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff);
   10741 
   10742       /* Values up to 2^31 - 1 are allowed.  Larger values would cause
   10743 	 sign extension at runtime in the stub, resulting in a negative
   10744 	 index value.  */
   10745       if (h->dynindx & ~0x7fffffff)
   10746 	return FALSE;
   10747 
   10748       /* Fill the stub.  */
   10749       if (micromips_p)
   10750 	{
   10751 	  idx = 0;
   10752 	  bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd),
   10753 				stub + idx);
   10754 	  idx += 4;
   10755 	  if (htab->insn32)
   10756 	    {
   10757 	      bfd_put_micromips_32 (output_bfd,
   10758 				    STUB_MOVE32_MICROMIPS (output_bfd),
   10759 				    stub + idx);
   10760 	      idx += 4;
   10761 	    }
   10762 	  else
   10763 	    {
   10764 	      bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx);
   10765 	      idx += 2;
   10766 	    }
   10767 	  if (stub_size == stub_big_size)
   10768 	    {
   10769 	      long dynindx_hi = (h->dynindx >> 16) & 0x7fff;
   10770 
   10771 	      bfd_put_micromips_32 (output_bfd,
   10772 				    STUB_LUI_MICROMIPS (dynindx_hi),
   10773 				    stub + idx);
   10774 	      idx += 4;
   10775 	    }
   10776 	  if (htab->insn32)
   10777 	    {
   10778 	      bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS,
   10779 				    stub + idx);
   10780 	      idx += 4;
   10781 	    }
   10782 	  else
   10783 	    {
   10784 	      bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx);
   10785 	      idx += 2;
   10786 	    }
   10787 
   10788 	  /* If a large stub is not required and sign extension is not a
   10789 	     problem, then use legacy code in the stub.  */
   10790 	  if (stub_size == stub_big_size)
   10791 	    bfd_put_micromips_32 (output_bfd,
   10792 				  STUB_ORI_MICROMIPS (h->dynindx & 0xffff),
   10793 				  stub + idx);
   10794 	  else if (h->dynindx & ~0x7fff)
   10795 	    bfd_put_micromips_32 (output_bfd,
   10796 				  STUB_LI16U_MICROMIPS (h->dynindx & 0xffff),
   10797 				  stub + idx);
   10798 	  else
   10799 	    bfd_put_micromips_32 (output_bfd,
   10800 				  STUB_LI16S_MICROMIPS (output_bfd,
   10801 							h->dynindx),
   10802 				  stub + idx);
   10803 	}
   10804       else
   10805 	{
   10806 	  idx = 0;
   10807 	  bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
   10808 	  idx += 4;
   10809 	  bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
   10810 	  idx += 4;
   10811 	  if (stub_size == stub_big_size)
   10812 	    {
   10813 	      bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
   10814 			  stub + idx);
   10815 	      idx += 4;
   10816 	    }
   10817 	  bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
   10818 	  idx += 4;
   10819 
   10820 	  /* If a large stub is not required and sign extension is not a
   10821 	     problem, then use legacy code in the stub.  */
   10822 	  if (stub_size == stub_big_size)
   10823 	    bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff),
   10824 			stub + idx);
   10825 	  else if (h->dynindx & ~0x7fff)
   10826 	    bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff),
   10827 			stub + idx);
   10828 	  else
   10829 	    bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
   10830 			stub + idx);
   10831 	}
   10832 
   10833       BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size);
   10834       memcpy (htab->sstubs->contents + h->plt.plist->stub_offset,
   10835 	      stub, stub_size);
   10836 
   10837       /* Mark the symbol as undefined.  stub_offset != -1 occurs
   10838 	 only for the referenced symbol.  */
   10839       sym->st_shndx = SHN_UNDEF;
   10840 
   10841       /* The run-time linker uses the st_value field of the symbol
   10842 	 to reset the global offset table entry for this external
   10843 	 to its stub address when unlinking a shared object.  */
   10844       sym->st_value = (htab->sstubs->output_section->vma
   10845 		       + htab->sstubs->output_offset
   10846 		       + h->plt.plist->stub_offset
   10847 		       + isa_bit);
   10848       sym->st_other = other;
   10849     }
   10850 
   10851   /* If we have a MIPS16 function with a stub, the dynamic symbol must
   10852      refer to the stub, since only the stub uses the standard calling
   10853      conventions.  */
   10854   if (h->dynindx != -1 && hmips->fn_stub != NULL)
   10855     {
   10856       BFD_ASSERT (hmips->need_fn_stub);
   10857       sym->st_value = (hmips->fn_stub->output_section->vma
   10858 		       + hmips->fn_stub->output_offset);
   10859       sym->st_size = hmips->fn_stub->size;
   10860       sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
   10861     }
   10862 
   10863   BFD_ASSERT (h->dynindx != -1
   10864 	      || h->forced_local);
   10865 
   10866   sgot = htab->sgot;
   10867   g = htab->got_info;
   10868   BFD_ASSERT (g != NULL);
   10869 
   10870   /* Run through the global symbol table, creating GOT entries for all
   10871      the symbols that need them.  */
   10872   if (hmips->global_got_area != GGA_NONE)
   10873     {
   10874       bfd_vma offset;
   10875       bfd_vma value;
   10876 
   10877       value = sym->st_value;
   10878       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
   10879       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
   10880     }
   10881 
   10882   if (hmips->global_got_area != GGA_NONE && g->next)
   10883     {
   10884       struct mips_got_entry e, *p;
   10885       bfd_vma entry;
   10886       bfd_vma offset;
   10887 
   10888       gg = g;
   10889 
   10890       e.abfd = output_bfd;
   10891       e.symndx = -1;
   10892       e.d.h = hmips;
   10893       e.tls_type = GOT_TLS_NONE;
   10894 
   10895       for (g = g->next; g->next != gg; g = g->next)
   10896 	{
   10897 	  if (g->got_entries
   10898 	      && (p = (struct mips_got_entry *) htab_find (g->got_entries,
   10899 							   &e)))
   10900 	    {
   10901 	      offset = p->gotidx;
   10902 	      BFD_ASSERT (offset > 0 && offset < htab->sgot->size);
   10903 	      if (info->shared
   10904 		  || (elf_hash_table (info)->dynamic_sections_created
   10905 		      && p->d.h != NULL
   10906 		      && p->d.h->root.def_dynamic
   10907 		      && !p->d.h->root.def_regular))
   10908 		{
   10909 		  /* Create an R_MIPS_REL32 relocation for this entry.  Due to
   10910 		     the various compatibility problems, it's easier to mock
   10911 		     up an R_MIPS_32 or R_MIPS_64 relocation and leave
   10912 		     mips_elf_create_dynamic_relocation to calculate the
   10913 		     appropriate addend.  */
   10914 		  Elf_Internal_Rela rel[3];
   10915 
   10916 		  memset (rel, 0, sizeof (rel));
   10917 		  if (ABI_64_P (output_bfd))
   10918 		    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
   10919 		  else
   10920 		    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
   10921 		  rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
   10922 
   10923 		  entry = 0;
   10924 		  if (! (mips_elf_create_dynamic_relocation
   10925 			 (output_bfd, info, rel,
   10926 			  e.d.h, NULL, sym->st_value, &entry, sgot)))
   10927 		    return FALSE;
   10928 		}
   10929 	      else
   10930 		entry = sym->st_value;
   10931 	      MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
   10932 	    }
   10933 	}
   10934     }
   10935 
   10936   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
   10937   name = h->root.root.string;
   10938   if (h == elf_hash_table (info)->hdynamic
   10939       || h == elf_hash_table (info)->hgot)
   10940     sym->st_shndx = SHN_ABS;
   10941   else if (strcmp (name, "_DYNAMIC_LINK") == 0
   10942 	   || strcmp (name, "_DYNAMIC_LINKING") == 0)
   10943     {
   10944       sym->st_shndx = SHN_ABS;
   10945       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
   10946       sym->st_value = 1;
   10947     }
   10948   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
   10949     {
   10950       sym->st_shndx = SHN_ABS;
   10951       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
   10952       sym->st_value = elf_gp (output_bfd);
   10953     }
   10954   else if (SGI_COMPAT (output_bfd))
   10955     {
   10956       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
   10957 	  || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
   10958 	{
   10959 	  sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
   10960 	  sym->st_other = STO_PROTECTED;
   10961 	  sym->st_value = 0;
   10962 	  sym->st_shndx = SHN_MIPS_DATA;
   10963 	}
   10964       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
   10965 	{
   10966 	  sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
   10967 	  sym->st_other = STO_PROTECTED;
   10968 	  sym->st_value = mips_elf_hash_table (info)->procedure_count;
   10969 	  sym->st_shndx = SHN_ABS;
   10970 	}
   10971       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
   10972 	{
   10973 	  if (h->type == STT_FUNC)
   10974 	    sym->st_shndx = SHN_MIPS_TEXT;
   10975 	  else if (h->type == STT_OBJECT)
   10976 	    sym->st_shndx = SHN_MIPS_DATA;
   10977 	}
   10978     }
   10979 
   10980   /* Emit a copy reloc, if needed.  */
   10981   if (h->needs_copy)
   10982     {
   10983       asection *s;
   10984       bfd_vma symval;
   10985 
   10986       BFD_ASSERT (h->dynindx != -1);
   10987       BFD_ASSERT (htab->use_plts_and_copy_relocs);
   10988 
   10989       s = mips_elf_rel_dyn_section (info, FALSE);
   10990       symval = (h->root.u.def.section->output_section->vma
   10991 		+ h->root.u.def.section->output_offset
   10992 		+ h->root.u.def.value);
   10993       mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
   10994 					  h->dynindx, R_MIPS_COPY, symval);
   10995     }
   10996 
   10997   /* Handle the IRIX6-specific symbols.  */
   10998   if (IRIX_COMPAT (output_bfd) == ict_irix6)
   10999     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
   11000 
   11001   /* Keep dynamic compressed symbols odd.  This allows the dynamic linker
   11002      to treat compressed symbols like any other.  */
   11003   if (ELF_ST_IS_MIPS16 (sym->st_other))
   11004     {
   11005       BFD_ASSERT (sym->st_value & 1);
   11006       sym->st_other -= STO_MIPS16;
   11007     }
   11008   else if (ELF_ST_IS_MICROMIPS (sym->st_other))
   11009     {
   11010       BFD_ASSERT (sym->st_value & 1);
   11011       sym->st_other -= STO_MICROMIPS;
   11012     }
   11013 
   11014   return TRUE;
   11015 }
   11016 
   11017 /* Likewise, for VxWorks.  */
   11018 
   11019 bfd_boolean
   11020 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
   11021 					 struct bfd_link_info *info,
   11022 					 struct elf_link_hash_entry *h,
   11023 					 Elf_Internal_Sym *sym)
   11024 {
   11025   bfd *dynobj;
   11026   asection *sgot;
   11027   struct mips_got_info *g;
   11028   struct mips_elf_link_hash_table *htab;
   11029   struct mips_elf_link_hash_entry *hmips;
   11030 
   11031   htab = mips_elf_hash_table (info);
   11032   BFD_ASSERT (htab != NULL);
   11033   dynobj = elf_hash_table (info)->dynobj;
   11034   hmips = (struct mips_elf_link_hash_entry *) h;
   11035 
   11036   if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE)
   11037     {
   11038       bfd_byte *loc;
   11039       bfd_vma plt_address, got_address, got_offset, branch_offset;
   11040       Elf_Internal_Rela rel;
   11041       static const bfd_vma *plt_entry;
   11042       bfd_vma gotplt_index;
   11043       bfd_vma plt_offset;
   11044 
   11045       plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
   11046       gotplt_index = h->plt.plist->gotplt_index;
   11047 
   11048       BFD_ASSERT (h->dynindx != -1);
   11049       BFD_ASSERT (htab->splt != NULL);
   11050       BFD_ASSERT (gotplt_index != MINUS_ONE);
   11051       BFD_ASSERT (plt_offset <= htab->splt->size);
   11052 
   11053       /* Calculate the address of the .plt entry.  */
   11054       plt_address = (htab->splt->output_section->vma
   11055 		     + htab->splt->output_offset
   11056 		     + plt_offset);
   11057 
   11058       /* Calculate the address of the .got.plt entry.  */
   11059       got_address = (htab->sgotplt->output_section->vma
   11060 		     + htab->sgotplt->output_offset
   11061 		     + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd));
   11062 
   11063       /* Calculate the offset of the .got.plt entry from
   11064 	 _GLOBAL_OFFSET_TABLE_.  */
   11065       got_offset = mips_elf_gotplt_index (info, h);
   11066 
   11067       /* Calculate the offset for the branch at the start of the PLT
   11068 	 entry.  The branch jumps to the beginning of .plt.  */
   11069       branch_offset = -(plt_offset / 4 + 1) & 0xffff;
   11070 
   11071       /* Fill in the initial value of the .got.plt entry.  */
   11072       bfd_put_32 (output_bfd, plt_address,
   11073 		  (htab->sgotplt->contents
   11074 		   + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)));
   11075 
   11076       /* Find out where the .plt entry should go.  */
   11077       loc = htab->splt->contents + plt_offset;
   11078 
   11079       if (info->shared)
   11080 	{
   11081 	  plt_entry = mips_vxworks_shared_plt_entry;
   11082 	  bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
   11083 	  bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
   11084 	}
   11085       else
   11086 	{
   11087 	  bfd_vma got_address_high, got_address_low;
   11088 
   11089 	  plt_entry = mips_vxworks_exec_plt_entry;
   11090 	  got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
   11091 	  got_address_low = got_address & 0xffff;
   11092 
   11093 	  bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
   11094 	  bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
   11095 	  bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
   11096 	  bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
   11097 	  bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
   11098 	  bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
   11099 	  bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
   11100 	  bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
   11101 
   11102 	  loc = (htab->srelplt2->contents
   11103 		 + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela));
   11104 
   11105 	  /* Emit a relocation for the .got.plt entry.  */
   11106 	  rel.r_offset = got_address;
   11107 	  rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
   11108 	  rel.r_addend = plt_offset;
   11109 	  bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11110 
   11111 	  /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
   11112 	  loc += sizeof (Elf32_External_Rela);
   11113 	  rel.r_offset = plt_address + 8;
   11114 	  rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
   11115 	  rel.r_addend = got_offset;
   11116 	  bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11117 
   11118 	  /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
   11119 	  loc += sizeof (Elf32_External_Rela);
   11120 	  rel.r_offset += 4;
   11121 	  rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
   11122 	  bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11123 	}
   11124 
   11125       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
   11126       loc = (htab->srelplt->contents
   11127 	     + gotplt_index * sizeof (Elf32_External_Rela));
   11128       rel.r_offset = got_address;
   11129       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
   11130       rel.r_addend = 0;
   11131       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11132 
   11133       if (!h->def_regular)
   11134 	sym->st_shndx = SHN_UNDEF;
   11135     }
   11136 
   11137   BFD_ASSERT (h->dynindx != -1 || h->forced_local);
   11138 
   11139   sgot = htab->sgot;
   11140   g = htab->got_info;
   11141   BFD_ASSERT (g != NULL);
   11142 
   11143   /* See if this symbol has an entry in the GOT.  */
   11144   if (hmips->global_got_area != GGA_NONE)
   11145     {
   11146       bfd_vma offset;
   11147       Elf_Internal_Rela outrel;
   11148       bfd_byte *loc;
   11149       asection *s;
   11150 
   11151       /* Install the symbol value in the GOT.   */
   11152       offset = mips_elf_primary_global_got_index (output_bfd, info, h);
   11153       MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
   11154 
   11155       /* Add a dynamic relocation for it.  */
   11156       s = mips_elf_rel_dyn_section (info, FALSE);
   11157       loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
   11158       outrel.r_offset = (sgot->output_section->vma
   11159 			 + sgot->output_offset
   11160 			 + offset);
   11161       outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
   11162       outrel.r_addend = 0;
   11163       bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
   11164     }
   11165 
   11166   /* Emit a copy reloc, if needed.  */
   11167   if (h->needs_copy)
   11168     {
   11169       Elf_Internal_Rela rel;
   11170 
   11171       BFD_ASSERT (h->dynindx != -1);
   11172 
   11173       rel.r_offset = (h->root.u.def.section->output_section->vma
   11174 		      + h->root.u.def.section->output_offset
   11175 		      + h->root.u.def.value);
   11176       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
   11177       rel.r_addend = 0;
   11178       bfd_elf32_swap_reloca_out (output_bfd, &rel,
   11179 				 htab->srelbss->contents
   11180 				 + (htab->srelbss->reloc_count
   11181 				    * sizeof (Elf32_External_Rela)));
   11182       ++htab->srelbss->reloc_count;
   11183     }
   11184 
   11185   /* If this is a mips16/microMIPS symbol, force the value to be even.  */
   11186   if (ELF_ST_IS_COMPRESSED (sym->st_other))
   11187     sym->st_value &= ~1;
   11188 
   11189   return TRUE;
   11190 }
   11191 
   11192 /* Write out a plt0 entry to the beginning of .plt.  */
   11193 
   11194 static bfd_boolean
   11195 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
   11196 {
   11197   bfd_byte *loc;
   11198   bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
   11199   static const bfd_vma *plt_entry;
   11200   struct mips_elf_link_hash_table *htab;
   11201 
   11202   htab = mips_elf_hash_table (info);
   11203   BFD_ASSERT (htab != NULL);
   11204 
   11205   if (ABI_64_P (output_bfd))
   11206     plt_entry = mips_n64_exec_plt0_entry;
   11207   else if (ABI_N32_P (output_bfd))
   11208     plt_entry = mips_n32_exec_plt0_entry;
   11209   else if (!htab->plt_header_is_comp)
   11210     plt_entry = mips_o32_exec_plt0_entry;
   11211   else if (htab->insn32)
   11212     plt_entry = micromips_insn32_o32_exec_plt0_entry;
   11213   else
   11214     plt_entry = micromips_o32_exec_plt0_entry;
   11215 
   11216   /* Calculate the value of .got.plt.  */
   11217   gotplt_value = (htab->sgotplt->output_section->vma
   11218 		  + htab->sgotplt->output_offset);
   11219   gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
   11220   gotplt_value_low = gotplt_value & 0xffff;
   11221 
   11222   /* The PLT sequence is not safe for N64 if .got.plt's address can
   11223      not be loaded in two instructions.  */
   11224   BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
   11225 	      || ~(gotplt_value | 0x7fffffff) == 0);
   11226 
   11227   /* Install the PLT header.  */
   11228   loc = htab->splt->contents;
   11229   if (plt_entry == micromips_o32_exec_plt0_entry)
   11230     {
   11231       bfd_vma gotpc_offset;
   11232       bfd_vma loc_address;
   11233       size_t i;
   11234 
   11235       BFD_ASSERT (gotplt_value % 4 == 0);
   11236 
   11237       loc_address = (htab->splt->output_section->vma
   11238 		     + htab->splt->output_offset);
   11239       gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3);
   11240 
   11241       /* ADDIUPC has a span of +/-16MB, check we're in range.  */
   11242       if (gotpc_offset + 0x1000000 >= 0x2000000)
   11243 	{
   11244 	  (*_bfd_error_handler)
   11245 	    (_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
   11246 	     output_bfd,
   11247 	     htab->sgotplt->output_section,
   11248 	     htab->splt->output_section,
   11249 	     (long) gotpc_offset);
   11250 	  bfd_set_error (bfd_error_no_error);
   11251 	  return FALSE;
   11252 	}
   11253       bfd_put_16 (output_bfd,
   11254 		  plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
   11255       bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
   11256       for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++)
   11257 	bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
   11258     }
   11259   else if (plt_entry == micromips_insn32_o32_exec_plt0_entry)
   11260     {
   11261       size_t i;
   11262 
   11263       bfd_put_16 (output_bfd, plt_entry[0], loc);
   11264       bfd_put_16 (output_bfd, gotplt_value_high, loc + 2);
   11265       bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
   11266       bfd_put_16 (output_bfd, gotplt_value_low, loc + 6);
   11267       bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
   11268       bfd_put_16 (output_bfd, gotplt_value_low, loc + 10);
   11269       for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++)
   11270 	bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
   11271     }
   11272   else
   11273     {
   11274       bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
   11275       bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
   11276       bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
   11277       bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
   11278       bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
   11279       bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
   11280       bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
   11281       bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
   11282     }
   11283 
   11284   return TRUE;
   11285 }
   11286 
   11287 /* Install the PLT header for a VxWorks executable and finalize the
   11288    contents of .rela.plt.unloaded.  */
   11289 
   11290 static void
   11291 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
   11292 {
   11293   Elf_Internal_Rela rela;
   11294   bfd_byte *loc;
   11295   bfd_vma got_value, got_value_high, got_value_low, plt_address;
   11296   static const bfd_vma *plt_entry;
   11297   struct mips_elf_link_hash_table *htab;
   11298 
   11299   htab = mips_elf_hash_table (info);
   11300   BFD_ASSERT (htab != NULL);
   11301 
   11302   plt_entry = mips_vxworks_exec_plt0_entry;
   11303 
   11304   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
   11305   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
   11306 	       + htab->root.hgot->root.u.def.section->output_offset
   11307 	       + htab->root.hgot->root.u.def.value);
   11308 
   11309   got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
   11310   got_value_low = got_value & 0xffff;
   11311 
   11312   /* Calculate the address of the PLT header.  */
   11313   plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
   11314 
   11315   /* Install the PLT header.  */
   11316   loc = htab->splt->contents;
   11317   bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
   11318   bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
   11319   bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
   11320   bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
   11321   bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
   11322   bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
   11323 
   11324   /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
   11325   loc = htab->srelplt2->contents;
   11326   rela.r_offset = plt_address;
   11327   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
   11328   rela.r_addend = 0;
   11329   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
   11330   loc += sizeof (Elf32_External_Rela);
   11331 
   11332   /* Output the relocation for the following addiu of
   11333      %lo(_GLOBAL_OFFSET_TABLE_).  */
   11334   rela.r_offset += 4;
   11335   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
   11336   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
   11337   loc += sizeof (Elf32_External_Rela);
   11338 
   11339   /* Fix up the remaining relocations.  They may have the wrong
   11340      symbol index for _G_O_T_ or _P_L_T_ depending on the order
   11341      in which symbols were output.  */
   11342   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
   11343     {
   11344       Elf_Internal_Rela rel;
   11345 
   11346       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
   11347       rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
   11348       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11349       loc += sizeof (Elf32_External_Rela);
   11350 
   11351       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
   11352       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
   11353       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11354       loc += sizeof (Elf32_External_Rela);
   11355 
   11356       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
   11357       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
   11358       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
   11359       loc += sizeof (Elf32_External_Rela);
   11360     }
   11361 }
   11362 
   11363 /* Install the PLT header for a VxWorks shared library.  */
   11364 
   11365 static void
   11366 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
   11367 {
   11368   unsigned int i;
   11369   struct mips_elf_link_hash_table *htab;
   11370 
   11371   htab = mips_elf_hash_table (info);
   11372   BFD_ASSERT (htab != NULL);
   11373 
   11374   /* We just need to copy the entry byte-by-byte.  */
   11375   for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
   11376     bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
   11377 		htab->splt->contents + i * 4);
   11378 }
   11379 
   11380 /* Finish up the dynamic sections.  */
   11381 
   11382 bfd_boolean
   11383 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
   11384 				       struct bfd_link_info *info)
   11385 {
   11386   bfd *dynobj;
   11387   asection *sdyn;
   11388   asection *sgot;
   11389   struct mips_got_info *gg, *g;
   11390   struct mips_elf_link_hash_table *htab;
   11391 
   11392   htab = mips_elf_hash_table (info);
   11393   BFD_ASSERT (htab != NULL);
   11394 
   11395   dynobj = elf_hash_table (info)->dynobj;
   11396 
   11397   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
   11398 
   11399   sgot = htab->sgot;
   11400   gg = htab->got_info;
   11401 
   11402   if (elf_hash_table (info)->dynamic_sections_created)
   11403     {
   11404       bfd_byte *b;
   11405       int dyn_to_skip = 0, dyn_skipped = 0;
   11406 
   11407       BFD_ASSERT (sdyn != NULL);
   11408       BFD_ASSERT (gg != NULL);
   11409 
   11410       g = mips_elf_bfd_got (output_bfd, FALSE);
   11411       BFD_ASSERT (g != NULL);
   11412 
   11413       for (b = sdyn->contents;
   11414 	   b < sdyn->contents + sdyn->size;
   11415 	   b += MIPS_ELF_DYN_SIZE (dynobj))
   11416 	{
   11417 	  Elf_Internal_Dyn dyn;
   11418 	  const char *name;
   11419 	  size_t elemsize;
   11420 	  asection *s;
   11421 	  bfd_boolean swap_out_p;
   11422 
   11423 	  /* Read in the current dynamic entry.  */
   11424 	  (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
   11425 
   11426 	  /* Assume that we're going to modify it and write it out.  */
   11427 	  swap_out_p = TRUE;
   11428 
   11429 	  switch (dyn.d_tag)
   11430 	    {
   11431 	    case DT_RELENT:
   11432 	      dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
   11433 	      break;
   11434 
   11435 	    case DT_RELAENT:
   11436 	      BFD_ASSERT (htab->is_vxworks);
   11437 	      dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
   11438 	      break;
   11439 
   11440 	    case DT_STRSZ:
   11441 	      /* Rewrite DT_STRSZ.  */
   11442 	      dyn.d_un.d_val =
   11443 		_bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
   11444 	      break;
   11445 
   11446 	    case DT_PLTGOT:
   11447 	      s = htab->sgot;
   11448 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
   11449 	      break;
   11450 
   11451 	    case DT_MIPS_PLTGOT:
   11452 	      s = htab->sgotplt;
   11453 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
   11454 	      break;
   11455 
   11456 	    case DT_MIPS_RLD_VERSION:
   11457 	      dyn.d_un.d_val = 1; /* XXX */
   11458 	      break;
   11459 
   11460 	    case DT_MIPS_FLAGS:
   11461 	      dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
   11462 	      break;
   11463 
   11464 	    case DT_MIPS_TIME_STAMP:
   11465 	      {
   11466 		time_t t;
   11467 		time (&t);
   11468 		dyn.d_un.d_val = t;
   11469 	      }
   11470 	      break;
   11471 
   11472 	    case DT_MIPS_ICHECKSUM:
   11473 	      /* XXX FIXME: */
   11474 	      swap_out_p = FALSE;
   11475 	      break;
   11476 
   11477 	    case DT_MIPS_IVERSION:
   11478 	      /* XXX FIXME: */
   11479 	      swap_out_p = FALSE;
   11480 	      break;
   11481 
   11482 	    case DT_MIPS_BASE_ADDRESS:
   11483 	      s = output_bfd->sections;
   11484 	      BFD_ASSERT (s != NULL);
   11485 	      dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
   11486 	      break;
   11487 
   11488 	    case DT_MIPS_LOCAL_GOTNO:
   11489 	      dyn.d_un.d_val = g->local_gotno;
   11490 	      break;
   11491 
   11492 	    case DT_MIPS_UNREFEXTNO:
   11493 	      /* The index into the dynamic symbol table which is the
   11494 		 entry of the first external symbol that is not
   11495 		 referenced within the same object.  */
   11496 	      dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
   11497 	      break;
   11498 
   11499 	    case DT_MIPS_GOTSYM:
   11500 	      if (htab->global_gotsym)
   11501 		{
   11502 		  dyn.d_un.d_val = htab->global_gotsym->dynindx;
   11503 		  break;
   11504 		}
   11505 	      /* In case if we don't have global got symbols we default
   11506 		 to setting DT_MIPS_GOTSYM to the same value as
   11507 		 DT_MIPS_SYMTABNO, so we just fall through.  */
   11508 
   11509 	    case DT_MIPS_SYMTABNO:
   11510 	      name = ".dynsym";
   11511 	      elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
   11512 	      s = bfd_get_section_by_name (output_bfd, name);
   11513 
   11514 	      if (s != NULL)
   11515 		dyn.d_un.d_val = s->size / elemsize;
   11516 	      else
   11517 		dyn.d_un.d_val = 0;
   11518 	      break;
   11519 
   11520 	    case DT_MIPS_HIPAGENO:
   11521 	      dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
   11522 	      break;
   11523 
   11524 	    case DT_MIPS_RLD_MAP:
   11525 	      {
   11526 		struct elf_link_hash_entry *h;
   11527 		h = mips_elf_hash_table (info)->rld_symbol;
   11528 		if (!h)
   11529 		  {
   11530 		    dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
   11531 		    swap_out_p = FALSE;
   11532 		    break;
   11533 		  }
   11534 		s = h->root.u.def.section;
   11535 
   11536 		/* The MIPS_RLD_MAP tag stores the absolute address of the
   11537 		   debug pointer.  */
   11538 		dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
   11539 				  + h->root.u.def.value);
   11540 	      }
   11541 	      break;
   11542 
   11543 	    case DT_MIPS_RLD_MAP_REL:
   11544 	      {
   11545 		struct elf_link_hash_entry *h;
   11546 		bfd_vma dt_addr, rld_addr;
   11547 		h = mips_elf_hash_table (info)->rld_symbol;
   11548 		if (!h)
   11549 		  {
   11550 		    dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
   11551 		    swap_out_p = FALSE;
   11552 		    break;
   11553 		  }
   11554 		s = h->root.u.def.section;
   11555 
   11556 		/* The MIPS_RLD_MAP_REL tag stores the offset to the debug
   11557 		   pointer, relative to the address of the tag.  */
   11558 		dt_addr = (sdyn->output_section->vma + sdyn->output_offset
   11559 			   + (b - sdyn->contents));
   11560 		rld_addr = (s->output_section->vma + s->output_offset
   11561 			    + h->root.u.def.value);
   11562 		dyn.d_un.d_ptr = rld_addr - dt_addr;
   11563 	      }
   11564 	      break;
   11565 
   11566 	    case DT_MIPS_OPTIONS:
   11567 	      s = (bfd_get_section_by_name
   11568 		   (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
   11569 	      dyn.d_un.d_ptr = s->vma;
   11570 	      break;
   11571 
   11572 	    case DT_RELASZ:
   11573 	      BFD_ASSERT (htab->is_vxworks);
   11574 	      /* The count does not include the JUMP_SLOT relocations.  */
   11575 	      if (htab->srelplt)
   11576 		dyn.d_un.d_val -= htab->srelplt->size;
   11577 	      break;
   11578 
   11579 	    case DT_PLTREL:
   11580 	      BFD_ASSERT (htab->use_plts_and_copy_relocs);
   11581 	      if (htab->is_vxworks)
   11582 		dyn.d_un.d_val = DT_RELA;
   11583 	      else
   11584 		dyn.d_un.d_val = DT_REL;
   11585 	      break;
   11586 
   11587 	    case DT_PLTRELSZ:
   11588 	      BFD_ASSERT (htab->use_plts_and_copy_relocs);
   11589 	      dyn.d_un.d_val = htab->srelplt->size;
   11590 	      break;
   11591 
   11592 	    case DT_JMPREL:
   11593 	      BFD_ASSERT (htab->use_plts_and_copy_relocs);
   11594 	      dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
   11595 				+ htab->srelplt->output_offset);
   11596 	      break;
   11597 
   11598 	    case DT_TEXTREL:
   11599 	      /* If we didn't need any text relocations after all, delete
   11600 		 the dynamic tag.  */
   11601 	      if (!(info->flags & DF_TEXTREL))
   11602 		{
   11603 		  dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
   11604 		  swap_out_p = FALSE;
   11605 		}
   11606 	      break;
   11607 
   11608 	    case DT_FLAGS:
   11609 	      /* If we didn't need any text relocations after all, clear
   11610 		 DF_TEXTREL from DT_FLAGS.  */
   11611 	      if (!(info->flags & DF_TEXTREL))
   11612 		dyn.d_un.d_val &= ~DF_TEXTREL;
   11613 	      else
   11614 		swap_out_p = FALSE;
   11615 	      break;
   11616 
   11617 	    default:
   11618 	      swap_out_p = FALSE;
   11619 	      if (htab->is_vxworks
   11620 		  && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
   11621 		swap_out_p = TRUE;
   11622 	      break;
   11623 	    }
   11624 
   11625 	  if (swap_out_p || dyn_skipped)
   11626 	    (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
   11627 	      (dynobj, &dyn, b - dyn_skipped);
   11628 
   11629 	  if (dyn_to_skip)
   11630 	    {
   11631 	      dyn_skipped += dyn_to_skip;
   11632 	      dyn_to_skip = 0;
   11633 	    }
   11634 	}
   11635 
   11636       /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
   11637       if (dyn_skipped > 0)
   11638 	memset (b - dyn_skipped, 0, dyn_skipped);
   11639     }
   11640 
   11641   if (sgot != NULL && sgot->size > 0
   11642       && !bfd_is_abs_section (sgot->output_section))
   11643     {
   11644       if (htab->is_vxworks)
   11645 	{
   11646 	  /* The first entry of the global offset table points to the
   11647 	     ".dynamic" section.  The second is initialized by the
   11648 	     loader and contains the shared library identifier.
   11649 	     The third is also initialized by the loader and points
   11650 	     to the lazy resolution stub.  */
   11651 	  MIPS_ELF_PUT_WORD (output_bfd,
   11652 			     sdyn->output_offset + sdyn->output_section->vma,
   11653 			     sgot->contents);
   11654 	  MIPS_ELF_PUT_WORD (output_bfd, 0,
   11655 			     sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
   11656 	  MIPS_ELF_PUT_WORD (output_bfd, 0,
   11657 			     sgot->contents
   11658 			     + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
   11659 	}
   11660       else
   11661 	{
   11662 	  /* The first entry of the global offset table will be filled at
   11663 	     runtime. The second entry will be used by some runtime loaders.
   11664 	     This isn't the case of IRIX rld.  */
   11665 	  MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
   11666 	  MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
   11667 			     sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
   11668 	}
   11669 
   11670       elf_section_data (sgot->output_section)->this_hdr.sh_entsize
   11671 	 = MIPS_ELF_GOT_SIZE (output_bfd);
   11672     }
   11673 
   11674   /* Generate dynamic relocations for the non-primary gots.  */
   11675   if (gg != NULL && gg->next)
   11676     {
   11677       Elf_Internal_Rela rel[3];
   11678       bfd_vma addend = 0;
   11679 
   11680       memset (rel, 0, sizeof (rel));
   11681       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
   11682 
   11683       for (g = gg->next; g->next != gg; g = g->next)
   11684 	{
   11685 	  bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
   11686 	    + g->next->tls_gotno;
   11687 
   11688 	  MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
   11689 			     + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
   11690 	  MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
   11691 			     sgot->contents
   11692 			     + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
   11693 
   11694 	  if (! info->shared)
   11695 	    continue;
   11696 
   11697 	  for (; got_index < g->local_gotno; got_index++)
   11698 	    {
   11699 	      if (got_index >= g->assigned_low_gotno
   11700 		  && got_index <= g->assigned_high_gotno)
   11701 		continue;
   11702 
   11703 	      rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
   11704 		= got_index * MIPS_ELF_GOT_SIZE (output_bfd);
   11705 	      if (!(mips_elf_create_dynamic_relocation
   11706 		    (output_bfd, info, rel, NULL,
   11707 		     bfd_abs_section_ptr,
   11708 		     0, &addend, sgot)))
   11709 		return FALSE;
   11710 	      BFD_ASSERT (addend == 0);
   11711 	    }
   11712 	}
   11713     }
   11714 
   11715   /* The generation of dynamic relocations for the non-primary gots
   11716      adds more dynamic relocations.  We cannot count them until
   11717      here.  */
   11718 
   11719   if (elf_hash_table (info)->dynamic_sections_created)
   11720     {
   11721       bfd_byte *b;
   11722       bfd_boolean swap_out_p;
   11723 
   11724       BFD_ASSERT (sdyn != NULL);
   11725 
   11726       for (b = sdyn->contents;
   11727 	   b < sdyn->contents + sdyn->size;
   11728 	   b += MIPS_ELF_DYN_SIZE (dynobj))
   11729 	{
   11730 	  Elf_Internal_Dyn dyn;
   11731 	  asection *s;
   11732 
   11733 	  /* Read in the current dynamic entry.  */
   11734 	  (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
   11735 
   11736 	  /* Assume that we're going to modify it and write it out.  */
   11737 	  swap_out_p = TRUE;
   11738 
   11739 	  switch (dyn.d_tag)
   11740 	    {
   11741 	    case DT_RELSZ:
   11742 	      /* Reduce DT_RELSZ to account for any relocations we
   11743 		 decided not to make.  This is for the n64 irix rld,
   11744 		 which doesn't seem to apply any relocations if there
   11745 		 are trailing null entries.  */
   11746 	      s = mips_elf_rel_dyn_section (info, FALSE);
   11747 	      dyn.d_un.d_val = (s->reloc_count
   11748 				* (ABI_64_P (output_bfd)
   11749 				   ? sizeof (Elf64_Mips_External_Rel)
   11750 				   : sizeof (Elf32_External_Rel)));
   11751 	      /* Adjust the section size too.  Tools like the prelinker
   11752 		 can reasonably expect the values to the same.  */
   11753 	      elf_section_data (s->output_section)->this_hdr.sh_size
   11754 		= dyn.d_un.d_val;
   11755 	      break;
   11756 
   11757 	    default:
   11758 	      swap_out_p = FALSE;
   11759 	      break;
   11760 	    }
   11761 
   11762 	  if (swap_out_p)
   11763 	    (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
   11764 	      (dynobj, &dyn, b);
   11765 	}
   11766     }
   11767 
   11768   {
   11769     asection *s;
   11770     Elf32_compact_rel cpt;
   11771 
   11772     if (SGI_COMPAT (output_bfd))
   11773       {
   11774 	/* Write .compact_rel section out.  */
   11775 	s = bfd_get_linker_section (dynobj, ".compact_rel");
   11776 	if (s != NULL)
   11777 	  {
   11778 	    cpt.id1 = 1;
   11779 	    cpt.num = s->reloc_count;
   11780 	    cpt.id2 = 2;
   11781 	    cpt.offset = (s->output_section->filepos
   11782 			  + sizeof (Elf32_External_compact_rel));
   11783 	    cpt.reserved0 = 0;
   11784 	    cpt.reserved1 = 0;
   11785 	    bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
   11786 					    ((Elf32_External_compact_rel *)
   11787 					     s->contents));
   11788 
   11789 	    /* Clean up a dummy stub function entry in .text.  */
   11790 	    if (htab->sstubs != NULL)
   11791 	      {
   11792 		file_ptr dummy_offset;
   11793 
   11794 		BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
   11795 		dummy_offset = htab->sstubs->size - htab->function_stub_size;
   11796 		memset (htab->sstubs->contents + dummy_offset, 0,
   11797 			htab->function_stub_size);
   11798 	      }
   11799 	  }
   11800       }
   11801 
   11802     /* The psABI says that the dynamic relocations must be sorted in
   11803        increasing order of r_symndx.  The VxWorks EABI doesn't require
   11804        this, and because the code below handles REL rather than RELA
   11805        relocations, using it for VxWorks would be outright harmful.  */
   11806     if (!htab->is_vxworks)
   11807       {
   11808 	s = mips_elf_rel_dyn_section (info, FALSE);
   11809 	if (s != NULL
   11810 	    && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
   11811 	  {
   11812 	    reldyn_sorting_bfd = output_bfd;
   11813 
   11814 	    if (ABI_64_P (output_bfd))
   11815 	      qsort ((Elf64_External_Rel *) s->contents + 1,
   11816 		     s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
   11817 		     sort_dynamic_relocs_64);
   11818 	    else
   11819 	      qsort ((Elf32_External_Rel *) s->contents + 1,
   11820 		     s->reloc_count - 1, sizeof (Elf32_External_Rel),
   11821 		     sort_dynamic_relocs);
   11822 	  }
   11823       }
   11824   }
   11825 
   11826   if (htab->splt && htab->splt->size > 0)
   11827     {
   11828       if (htab->is_vxworks)
   11829 	{
   11830 	  if (info->shared)
   11831 	    mips_vxworks_finish_shared_plt (output_bfd, info);
   11832 	  else
   11833 	    mips_vxworks_finish_exec_plt (output_bfd, info);
   11834 	}
   11835       else
   11836 	{
   11837 	  BFD_ASSERT (!info->shared);
   11838 	  if (!mips_finish_exec_plt (output_bfd, info))
   11839 	    return FALSE;
   11840 	}
   11841     }
   11842   return TRUE;
   11843 }
   11844 
   11845 
   11846 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
   11847 
   11848 static void
   11849 mips_set_isa_flags (bfd *abfd)
   11850 {
   11851   flagword val;
   11852 
   11853   switch (bfd_get_mach (abfd))
   11854     {
   11855     default:
   11856     case bfd_mach_mips3000:
   11857       val = E_MIPS_ARCH_1;
   11858       break;
   11859 
   11860     case bfd_mach_mips3900:
   11861       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
   11862       break;
   11863 
   11864     case bfd_mach_mips6000:
   11865       val = E_MIPS_ARCH_2;
   11866       break;
   11867 
   11868     case bfd_mach_mips4000:
   11869     case bfd_mach_mips4300:
   11870     case bfd_mach_mips4400:
   11871     case bfd_mach_mips4600:
   11872       val = E_MIPS_ARCH_3;
   11873       break;
   11874 
   11875     case bfd_mach_mips4010:
   11876       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
   11877       break;
   11878 
   11879     case bfd_mach_mips4100:
   11880       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
   11881       break;
   11882 
   11883     case bfd_mach_mips4111:
   11884       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
   11885       break;
   11886 
   11887     case bfd_mach_mips4120:
   11888       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
   11889       break;
   11890 
   11891     case bfd_mach_mips4650:
   11892       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
   11893       break;
   11894 
   11895     case bfd_mach_mips5400:
   11896       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
   11897       break;
   11898 
   11899     case bfd_mach_mips5500:
   11900       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
   11901       break;
   11902 
   11903     case bfd_mach_mips5900:
   11904       val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
   11905       break;
   11906 
   11907     case bfd_mach_mips9000:
   11908       val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
   11909       break;
   11910 
   11911     case bfd_mach_mips5000:
   11912     case bfd_mach_mips7000:
   11913     case bfd_mach_mips8000:
   11914     case bfd_mach_mips10000:
   11915     case bfd_mach_mips12000:
   11916     case bfd_mach_mips14000:
   11917     case bfd_mach_mips16000:
   11918       val = E_MIPS_ARCH_4;
   11919       break;
   11920 
   11921     case bfd_mach_mips5:
   11922       val = E_MIPS_ARCH_5;
   11923       break;
   11924 
   11925     case bfd_mach_mips_loongson_2e:
   11926       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
   11927       break;
   11928 
   11929     case bfd_mach_mips_loongson_2f:
   11930       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
   11931       break;
   11932 
   11933     case bfd_mach_mips_sb1:
   11934       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
   11935       break;
   11936 
   11937     case bfd_mach_mips_loongson_3a:
   11938       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_LS3A;
   11939       break;
   11940 
   11941     case bfd_mach_mips_octeon:
   11942     case bfd_mach_mips_octeonp:
   11943       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
   11944       break;
   11945 
   11946     case bfd_mach_mips_octeon3:
   11947       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3;
   11948       break;
   11949 
   11950     case bfd_mach_mips_xlr:
   11951       val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
   11952       break;
   11953 
   11954     case bfd_mach_mips_octeon2:
   11955       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
   11956       break;
   11957 
   11958     case bfd_mach_mipsisa32:
   11959       val = E_MIPS_ARCH_32;
   11960       break;
   11961 
   11962     case bfd_mach_mipsisa64:
   11963       val = E_MIPS_ARCH_64;
   11964       break;
   11965 
   11966     case bfd_mach_mipsisa32r2:
   11967     case bfd_mach_mipsisa32r3:
   11968     case bfd_mach_mipsisa32r5:
   11969       val = E_MIPS_ARCH_32R2;
   11970       break;
   11971 
   11972     case bfd_mach_mipsisa64r2:
   11973     case bfd_mach_mipsisa64r3:
   11974     case bfd_mach_mipsisa64r5:
   11975       val = E_MIPS_ARCH_64R2;
   11976       break;
   11977 
   11978     case bfd_mach_mipsisa32r6:
   11979       val = E_MIPS_ARCH_32R6;
   11980       break;
   11981 
   11982     case bfd_mach_mipsisa64r6:
   11983       val = E_MIPS_ARCH_64R6;
   11984       break;
   11985     }
   11986   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
   11987   elf_elfheader (abfd)->e_flags |= val;
   11988 
   11989 }
   11990 
   11991 
   11992 /* The final processing done just before writing out a MIPS ELF object
   11993    file.  This gets the MIPS architecture right based on the machine
   11994    number.  This is used by both the 32-bit and the 64-bit ABI.  */
   11995 
   11996 void
   11997 _bfd_mips_elf_final_write_processing (bfd *abfd,
   11998 				      bfd_boolean linker ATTRIBUTE_UNUSED)
   11999 {
   12000   unsigned int i;
   12001   Elf_Internal_Shdr **hdrpp;
   12002   const char *name;
   12003   asection *sec;
   12004 
   12005   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
   12006      is nonzero.  This is for compatibility with old objects, which used
   12007      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
   12008   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
   12009     mips_set_isa_flags (abfd);
   12010 
   12011   /* Set the sh_info field for .gptab sections and other appropriate
   12012      info for each special section.  */
   12013   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
   12014        i < elf_numsections (abfd);
   12015        i++, hdrpp++)
   12016     {
   12017       switch ((*hdrpp)->sh_type)
   12018 	{
   12019 	case SHT_MIPS_MSYM:
   12020 	case SHT_MIPS_LIBLIST:
   12021 	  sec = bfd_get_section_by_name (abfd, ".dynstr");
   12022 	  if (sec != NULL)
   12023 	    (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
   12024 	  break;
   12025 
   12026 	case SHT_MIPS_GPTAB:
   12027 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
   12028 	  name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
   12029 	  BFD_ASSERT (name != NULL
   12030 		      && CONST_STRNEQ (name, ".gptab."));
   12031 	  sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
   12032 	  BFD_ASSERT (sec != NULL);
   12033 	  (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
   12034 	  break;
   12035 
   12036 	case SHT_MIPS_CONTENT:
   12037 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
   12038 	  name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
   12039 	  BFD_ASSERT (name != NULL
   12040 		      && CONST_STRNEQ (name, ".MIPS.content"));
   12041 	  sec = bfd_get_section_by_name (abfd,
   12042 					 name + sizeof ".MIPS.content" - 1);
   12043 	  BFD_ASSERT (sec != NULL);
   12044 	  (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
   12045 	  break;
   12046 
   12047 	case SHT_MIPS_SYMBOL_LIB:
   12048 	  sec = bfd_get_section_by_name (abfd, ".dynsym");
   12049 	  if (sec != NULL)
   12050 	    (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
   12051 	  sec = bfd_get_section_by_name (abfd, ".liblist");
   12052 	  if (sec != NULL)
   12053 	    (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
   12054 	  break;
   12055 
   12056 	case SHT_MIPS_EVENTS:
   12057 	  BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
   12058 	  name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
   12059 	  BFD_ASSERT (name != NULL);
   12060 	  if (CONST_STRNEQ (name, ".MIPS.events"))
   12061 	    sec = bfd_get_section_by_name (abfd,
   12062 					   name + sizeof ".MIPS.events" - 1);
   12063 	  else
   12064 	    {
   12065 	      BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
   12066 	      sec = bfd_get_section_by_name (abfd,
   12067 					     (name
   12068 					      + sizeof ".MIPS.post_rel" - 1));
   12069 	    }
   12070 	  BFD_ASSERT (sec != NULL);
   12071 	  (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
   12072 	  break;
   12073 
   12074 	}
   12075     }
   12076 }
   12077 
   12078 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
   12080    segments.  */
   12081 
   12082 int
   12083 _bfd_mips_elf_additional_program_headers (bfd *abfd,
   12084 					  struct bfd_link_info *info ATTRIBUTE_UNUSED)
   12085 {
   12086   asection *s;
   12087   int ret = 0;
   12088 
   12089   /* See if we need a PT_MIPS_REGINFO segment.  */
   12090   s = bfd_get_section_by_name (abfd, ".reginfo");
   12091   if (s && (s->flags & SEC_LOAD))
   12092     ++ret;
   12093 
   12094   /* See if we need a PT_MIPS_ABIFLAGS segment.  */
   12095   if (bfd_get_section_by_name (abfd, ".MIPS.abiflags"))
   12096     ++ret;
   12097 
   12098   /* See if we need a PT_MIPS_OPTIONS segment.  */
   12099   if (IRIX_COMPAT (abfd) == ict_irix6
   12100       && bfd_get_section_by_name (abfd,
   12101 				  MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
   12102     ++ret;
   12103 
   12104   /* See if we need a PT_MIPS_RTPROC segment.  */
   12105   if (IRIX_COMPAT (abfd) == ict_irix5
   12106       && bfd_get_section_by_name (abfd, ".dynamic")
   12107       && bfd_get_section_by_name (abfd, ".mdebug"))
   12108     ++ret;
   12109 
   12110   /* Allocate a PT_NULL header in dynamic objects.  See
   12111      _bfd_mips_elf_modify_segment_map for details.  */
   12112   if (!SGI_COMPAT (abfd)
   12113       && bfd_get_section_by_name (abfd, ".dynamic"))
   12114     ++ret;
   12115 
   12116   return ret;
   12117 }
   12118 
   12119 /* Modify the segment map for an IRIX5 executable.  */
   12120 
   12121 bfd_boolean
   12122 _bfd_mips_elf_modify_segment_map (bfd *abfd,
   12123 				  struct bfd_link_info *info)
   12124 {
   12125   asection *s;
   12126   struct elf_segment_map *m, **pm;
   12127   bfd_size_type amt;
   12128 
   12129   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
   12130      segment.  */
   12131   s = bfd_get_section_by_name (abfd, ".reginfo");
   12132   if (s != NULL && (s->flags & SEC_LOAD) != 0)
   12133     {
   12134       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
   12135 	if (m->p_type == PT_MIPS_REGINFO)
   12136 	  break;
   12137       if (m == NULL)
   12138 	{
   12139 	  amt = sizeof *m;
   12140 	  m = bfd_zalloc (abfd, amt);
   12141 	  if (m == NULL)
   12142 	    return FALSE;
   12143 
   12144 	  m->p_type = PT_MIPS_REGINFO;
   12145 	  m->count = 1;
   12146 	  m->sections[0] = s;
   12147 
   12148 	  /* We want to put it after the PHDR and INTERP segments.  */
   12149 	  pm = &elf_seg_map (abfd);
   12150 	  while (*pm != NULL
   12151 		 && ((*pm)->p_type == PT_PHDR
   12152 		     || (*pm)->p_type == PT_INTERP))
   12153 	    pm = &(*pm)->next;
   12154 
   12155 	  m->next = *pm;
   12156 	  *pm = m;
   12157 	}
   12158     }
   12159 
   12160   /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
   12161      segment.  */
   12162   s = bfd_get_section_by_name (abfd, ".MIPS.abiflags");
   12163   if (s != NULL && (s->flags & SEC_LOAD) != 0)
   12164     {
   12165       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
   12166 	if (m->p_type == PT_MIPS_ABIFLAGS)
   12167 	  break;
   12168       if (m == NULL)
   12169 	{
   12170 	  amt = sizeof *m;
   12171 	  m = bfd_zalloc (abfd, amt);
   12172 	  if (m == NULL)
   12173 	    return FALSE;
   12174 
   12175 	  m->p_type = PT_MIPS_ABIFLAGS;
   12176 	  m->count = 1;
   12177 	  m->sections[0] = s;
   12178 
   12179 	  /* We want to put it after the PHDR and INTERP segments.  */
   12180 	  pm = &elf_seg_map (abfd);
   12181 	  while (*pm != NULL
   12182 		 && ((*pm)->p_type == PT_PHDR
   12183 		     || (*pm)->p_type == PT_INTERP))
   12184 	    pm = &(*pm)->next;
   12185 
   12186 	  m->next = *pm;
   12187 	  *pm = m;
   12188 	}
   12189     }
   12190 
   12191   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
   12192      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
   12193      PT_MIPS_OPTIONS segment immediately following the program header
   12194      table.  */
   12195   if (NEWABI_P (abfd)
   12196       /* On non-IRIX6 new abi, we'll have already created a segment
   12197 	 for this section, so don't create another.  I'm not sure this
   12198 	 is not also the case for IRIX 6, but I can't test it right
   12199 	 now.  */
   12200       && IRIX_COMPAT (abfd) == ict_irix6)
   12201     {
   12202       for (s = abfd->sections; s; s = s->next)
   12203 	if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
   12204 	  break;
   12205 
   12206       if (s)
   12207 	{
   12208 	  struct elf_segment_map *options_segment;
   12209 
   12210 	  pm = &elf_seg_map (abfd);
   12211 	  while (*pm != NULL
   12212 		 && ((*pm)->p_type == PT_PHDR
   12213 		     || (*pm)->p_type == PT_INTERP))
   12214 	    pm = &(*pm)->next;
   12215 
   12216 	  if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
   12217 	    {
   12218 	      amt = sizeof (struct elf_segment_map);
   12219 	      options_segment = bfd_zalloc (abfd, amt);
   12220 	      options_segment->next = *pm;
   12221 	      options_segment->p_type = PT_MIPS_OPTIONS;
   12222 	      options_segment->p_flags = PF_R;
   12223 	      options_segment->p_flags_valid = TRUE;
   12224 	      options_segment->count = 1;
   12225 	      options_segment->sections[0] = s;
   12226 	      *pm = options_segment;
   12227 	    }
   12228 	}
   12229     }
   12230   else
   12231     {
   12232       if (IRIX_COMPAT (abfd) == ict_irix5)
   12233 	{
   12234 	  /* If there are .dynamic and .mdebug sections, we make a room
   12235 	     for the RTPROC header.  FIXME: Rewrite without section names.  */
   12236 	  if (bfd_get_section_by_name (abfd, ".interp") == NULL
   12237 	      && bfd_get_section_by_name (abfd, ".dynamic") != NULL
   12238 	      && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
   12239 	    {
   12240 	      for (m = elf_seg_map (abfd); m != NULL; m = m->next)
   12241 		if (m->p_type == PT_MIPS_RTPROC)
   12242 		  break;
   12243 	      if (m == NULL)
   12244 		{
   12245 		  amt = sizeof *m;
   12246 		  m = bfd_zalloc (abfd, amt);
   12247 		  if (m == NULL)
   12248 		    return FALSE;
   12249 
   12250 		  m->p_type = PT_MIPS_RTPROC;
   12251 
   12252 		  s = bfd_get_section_by_name (abfd, ".rtproc");
   12253 		  if (s == NULL)
   12254 		    {
   12255 		      m->count = 0;
   12256 		      m->p_flags = 0;
   12257 		      m->p_flags_valid = 1;
   12258 		    }
   12259 		  else
   12260 		    {
   12261 		      m->count = 1;
   12262 		      m->sections[0] = s;
   12263 		    }
   12264 
   12265 		  /* We want to put it after the DYNAMIC segment.  */
   12266 		  pm = &elf_seg_map (abfd);
   12267 		  while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
   12268 		    pm = &(*pm)->next;
   12269 		  if (*pm != NULL)
   12270 		    pm = &(*pm)->next;
   12271 
   12272 		  m->next = *pm;
   12273 		  *pm = m;
   12274 		}
   12275 	    }
   12276 	}
   12277       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
   12278 	 .dynstr, .dynsym, and .hash sections, and everything in
   12279 	 between.  */
   12280       for (pm = &elf_seg_map (abfd); *pm != NULL;
   12281 	   pm = &(*pm)->next)
   12282 	if ((*pm)->p_type == PT_DYNAMIC)
   12283 	  break;
   12284       m = *pm;
   12285       /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
   12286 	 glibc's dynamic linker has traditionally derived the number of
   12287 	 tags from the p_filesz field, and sometimes allocates stack
   12288 	 arrays of that size.  An overly-big PT_DYNAMIC segment can
   12289 	 be actively harmful in such cases.  Making PT_DYNAMIC contain
   12290 	 other sections can also make life hard for the prelinker,
   12291 	 which might move one of the other sections to a different
   12292 	 PT_LOAD segment.  */
   12293       if (SGI_COMPAT (abfd)
   12294 	  && m != NULL
   12295 	  && m->count == 1
   12296 	  && strcmp (m->sections[0]->name, ".dynamic") == 0)
   12297 	{
   12298 	  static const char *sec_names[] =
   12299 	  {
   12300 	    ".dynamic", ".dynstr", ".dynsym", ".hash"
   12301 	  };
   12302 	  bfd_vma low, high;
   12303 	  unsigned int i, c;
   12304 	  struct elf_segment_map *n;
   12305 
   12306 	  low = ~(bfd_vma) 0;
   12307 	  high = 0;
   12308 	  for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
   12309 	    {
   12310 	      s = bfd_get_section_by_name (abfd, sec_names[i]);
   12311 	      if (s != NULL && (s->flags & SEC_LOAD) != 0)
   12312 		{
   12313 		  bfd_size_type sz;
   12314 
   12315 		  if (low > s->vma)
   12316 		    low = s->vma;
   12317 		  sz = s->size;
   12318 		  if (high < s->vma + sz)
   12319 		    high = s->vma + sz;
   12320 		}
   12321 	    }
   12322 
   12323 	  c = 0;
   12324 	  for (s = abfd->sections; s != NULL; s = s->next)
   12325 	    if ((s->flags & SEC_LOAD) != 0
   12326 		&& s->vma >= low
   12327 		&& s->vma + s->size <= high)
   12328 	      ++c;
   12329 
   12330 	  amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
   12331 	  n = bfd_zalloc (abfd, amt);
   12332 	  if (n == NULL)
   12333 	    return FALSE;
   12334 	  *n = *m;
   12335 	  n->count = c;
   12336 
   12337 	  i = 0;
   12338 	  for (s = abfd->sections; s != NULL; s = s->next)
   12339 	    {
   12340 	      if ((s->flags & SEC_LOAD) != 0
   12341 		  && s->vma >= low
   12342 		  && s->vma + s->size <= high)
   12343 		{
   12344 		  n->sections[i] = s;
   12345 		  ++i;
   12346 		}
   12347 	    }
   12348 
   12349 	  *pm = n;
   12350 	}
   12351     }
   12352 
   12353   /* Allocate a spare program header in dynamic objects so that tools
   12354      like the prelinker can add an extra PT_LOAD entry.
   12355 
   12356      If the prelinker needs to make room for a new PT_LOAD entry, its
   12357      standard procedure is to move the first (read-only) sections into
   12358      the new (writable) segment.  However, the MIPS ABI requires
   12359      .dynamic to be in a read-only segment, and the section will often
   12360      start within sizeof (ElfNN_Phdr) bytes of the last program header.
   12361 
   12362      Although the prelinker could in principle move .dynamic to a
   12363      writable segment, it seems better to allocate a spare program
   12364      header instead, and avoid the need to move any sections.
   12365      There is a long tradition of allocating spare dynamic tags,
   12366      so allocating a spare program header seems like a natural
   12367      extension.
   12368 
   12369      If INFO is NULL, we may be copying an already prelinked binary
   12370      with objcopy or strip, so do not add this header.  */
   12371   if (info != NULL
   12372       && !SGI_COMPAT (abfd)
   12373       && bfd_get_section_by_name (abfd, ".dynamic"))
   12374     {
   12375       for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
   12376 	if ((*pm)->p_type == PT_NULL)
   12377 	  break;
   12378       if (*pm == NULL)
   12379 	{
   12380 	  m = bfd_zalloc (abfd, sizeof (*m));
   12381 	  if (m == NULL)
   12382 	    return FALSE;
   12383 
   12384 	  m->p_type = PT_NULL;
   12385 	  *pm = m;
   12386 	}
   12387     }
   12388 
   12389   return TRUE;
   12390 }
   12391 
   12392 /* Return the section that should be marked against GC for a given
   12394    relocation.  */
   12395 
   12396 asection *
   12397 _bfd_mips_elf_gc_mark_hook (asection *sec,
   12398 			    struct bfd_link_info *info,
   12399 			    Elf_Internal_Rela *rel,
   12400 			    struct elf_link_hash_entry *h,
   12401 			    Elf_Internal_Sym *sym)
   12402 {
   12403   /* ??? Do mips16 stub sections need to be handled special?  */
   12404 
   12405   if (h != NULL)
   12406     switch (ELF_R_TYPE (sec->owner, rel->r_info))
   12407       {
   12408       case R_MIPS_GNU_VTINHERIT:
   12409       case R_MIPS_GNU_VTENTRY:
   12410 	return NULL;
   12411       }
   12412 
   12413   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
   12414 }
   12415 
   12416 /* Update the got entry reference counts for the section being removed.  */
   12417 
   12418 bfd_boolean
   12419 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
   12420 			     struct bfd_link_info *info ATTRIBUTE_UNUSED,
   12421 			     asection *sec ATTRIBUTE_UNUSED,
   12422 			     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
   12423 {
   12424 #if 0
   12425   Elf_Internal_Shdr *symtab_hdr;
   12426   struct elf_link_hash_entry **sym_hashes;
   12427   bfd_signed_vma *local_got_refcounts;
   12428   const Elf_Internal_Rela *rel, *relend;
   12429   unsigned long r_symndx;
   12430   struct elf_link_hash_entry *h;
   12431 
   12432   if (info->relocatable)
   12433     return TRUE;
   12434 
   12435   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   12436   sym_hashes = elf_sym_hashes (abfd);
   12437   local_got_refcounts = elf_local_got_refcounts (abfd);
   12438 
   12439   relend = relocs + sec->reloc_count;
   12440   for (rel = relocs; rel < relend; rel++)
   12441     switch (ELF_R_TYPE (abfd, rel->r_info))
   12442       {
   12443       case R_MIPS16_GOT16:
   12444       case R_MIPS16_CALL16:
   12445       case R_MIPS_GOT16:
   12446       case R_MIPS_CALL16:
   12447       case R_MIPS_CALL_HI16:
   12448       case R_MIPS_CALL_LO16:
   12449       case R_MIPS_GOT_HI16:
   12450       case R_MIPS_GOT_LO16:
   12451       case R_MIPS_GOT_DISP:
   12452       case R_MIPS_GOT_PAGE:
   12453       case R_MIPS_GOT_OFST:
   12454       case R_MICROMIPS_GOT16:
   12455       case R_MICROMIPS_CALL16:
   12456       case R_MICROMIPS_CALL_HI16:
   12457       case R_MICROMIPS_CALL_LO16:
   12458       case R_MICROMIPS_GOT_HI16:
   12459       case R_MICROMIPS_GOT_LO16:
   12460       case R_MICROMIPS_GOT_DISP:
   12461       case R_MICROMIPS_GOT_PAGE:
   12462       case R_MICROMIPS_GOT_OFST:
   12463 	/* ??? It would seem that the existing MIPS code does no sort
   12464 	   of reference counting or whatnot on its GOT and PLT entries,
   12465 	   so it is not possible to garbage collect them at this time.  */
   12466 	break;
   12467 
   12468       default:
   12469 	break;
   12470       }
   12471 #endif
   12472 
   12473   return TRUE;
   12474 }
   12475 
   12476 /* Prevent .MIPS.abiflags from being discarded with --gc-sections.  */
   12477 
   12478 bfd_boolean
   12479 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info,
   12480 				      elf_gc_mark_hook_fn gc_mark_hook)
   12481 {
   12482   bfd *sub;
   12483 
   12484   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
   12485 
   12486   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
   12487     {
   12488       asection *o;
   12489 
   12490       if (! is_mips_elf (sub))
   12491 	continue;
   12492 
   12493       for (o = sub->sections; o != NULL; o = o->next)
   12494 	if (!o->gc_mark
   12495 	    && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
   12496 		 (bfd_get_section_name (sub, o)))
   12497 	  {
   12498 	    if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
   12499 	      return FALSE;
   12500 	  }
   12501     }
   12502 
   12503   return TRUE;
   12504 }
   12505 
   12506 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
   12508    hiding the old indirect symbol.  Process additional relocation
   12509    information.  Also called for weakdefs, in which case we just let
   12510    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
   12511 
   12512 void
   12513 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
   12514 				    struct elf_link_hash_entry *dir,
   12515 				    struct elf_link_hash_entry *ind)
   12516 {
   12517   struct mips_elf_link_hash_entry *dirmips, *indmips;
   12518 
   12519   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
   12520 
   12521   dirmips = (struct mips_elf_link_hash_entry *) dir;
   12522   indmips = (struct mips_elf_link_hash_entry *) ind;
   12523   /* Any absolute non-dynamic relocations against an indirect or weak
   12524      definition will be against the target symbol.  */
   12525   if (indmips->has_static_relocs)
   12526     dirmips->has_static_relocs = TRUE;
   12527 
   12528   if (ind->root.type != bfd_link_hash_indirect)
   12529     return;
   12530 
   12531   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
   12532   if (indmips->readonly_reloc)
   12533     dirmips->readonly_reloc = TRUE;
   12534   if (indmips->no_fn_stub)
   12535     dirmips->no_fn_stub = TRUE;
   12536   if (indmips->fn_stub)
   12537     {
   12538       dirmips->fn_stub = indmips->fn_stub;
   12539       indmips->fn_stub = NULL;
   12540     }
   12541   if (indmips->need_fn_stub)
   12542     {
   12543       dirmips->need_fn_stub = TRUE;
   12544       indmips->need_fn_stub = FALSE;
   12545     }
   12546   if (indmips->call_stub)
   12547     {
   12548       dirmips->call_stub = indmips->call_stub;
   12549       indmips->call_stub = NULL;
   12550     }
   12551   if (indmips->call_fp_stub)
   12552     {
   12553       dirmips->call_fp_stub = indmips->call_fp_stub;
   12554       indmips->call_fp_stub = NULL;
   12555     }
   12556   if (indmips->global_got_area < dirmips->global_got_area)
   12557     dirmips->global_got_area = indmips->global_got_area;
   12558   if (indmips->global_got_area < GGA_NONE)
   12559     indmips->global_got_area = GGA_NONE;
   12560   if (indmips->has_nonpic_branches)
   12561     dirmips->has_nonpic_branches = TRUE;
   12562 }
   12563 
   12564 #define PDR_SIZE 32
   12566 
   12567 bfd_boolean
   12568 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
   12569 			    struct bfd_link_info *info)
   12570 {
   12571   asection *o;
   12572   bfd_boolean ret = FALSE;
   12573   unsigned char *tdata;
   12574   size_t i, skip;
   12575 
   12576   o = bfd_get_section_by_name (abfd, ".pdr");
   12577   if (! o)
   12578     return FALSE;
   12579   if (o->size == 0)
   12580     return FALSE;
   12581   if (o->size % PDR_SIZE != 0)
   12582     return FALSE;
   12583   if (o->output_section != NULL
   12584       && bfd_is_abs_section (o->output_section))
   12585     return FALSE;
   12586 
   12587   tdata = bfd_zmalloc (o->size / PDR_SIZE);
   12588   if (! tdata)
   12589     return FALSE;
   12590 
   12591   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
   12592 					    info->keep_memory);
   12593   if (!cookie->rels)
   12594     {
   12595       free (tdata);
   12596       return FALSE;
   12597     }
   12598 
   12599   cookie->rel = cookie->rels;
   12600   cookie->relend = cookie->rels + o->reloc_count;
   12601 
   12602   for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
   12603     {
   12604       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
   12605 	{
   12606 	  tdata[i] = 1;
   12607 	  skip ++;
   12608 	}
   12609     }
   12610 
   12611   if (skip != 0)
   12612     {
   12613       mips_elf_section_data (o)->u.tdata = tdata;
   12614       if (o->rawsize == 0)
   12615 	o->rawsize = o->size;
   12616       o->size -= skip * PDR_SIZE;
   12617       ret = TRUE;
   12618     }
   12619   else
   12620     free (tdata);
   12621 
   12622   if (! info->keep_memory)
   12623     free (cookie->rels);
   12624 
   12625   return ret;
   12626 }
   12627 
   12628 bfd_boolean
   12629 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
   12630 {
   12631   if (strcmp (sec->name, ".pdr") == 0)
   12632     return TRUE;
   12633   return FALSE;
   12634 }
   12635 
   12636 bfd_boolean
   12637 _bfd_mips_elf_write_section (bfd *output_bfd,
   12638 			     struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
   12639                              asection *sec, bfd_byte *contents)
   12640 {
   12641   bfd_byte *to, *from, *end;
   12642   int i;
   12643 
   12644   if (strcmp (sec->name, ".pdr") != 0)
   12645     return FALSE;
   12646 
   12647   if (mips_elf_section_data (sec)->u.tdata == NULL)
   12648     return FALSE;
   12649 
   12650   to = contents;
   12651   end = contents + sec->size;
   12652   for (from = contents, i = 0;
   12653        from < end;
   12654        from += PDR_SIZE, i++)
   12655     {
   12656       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
   12657 	continue;
   12658       if (to != from)
   12659 	memcpy (to, from, PDR_SIZE);
   12660       to += PDR_SIZE;
   12661     }
   12662   bfd_set_section_contents (output_bfd, sec->output_section, contents,
   12663 			    sec->output_offset, sec->size);
   12664   return TRUE;
   12665 }
   12666 
   12667 /* microMIPS code retains local labels for linker relaxation.  Omit them
   12669    from output by default for clarity.  */
   12670 
   12671 bfd_boolean
   12672 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
   12673 {
   12674   return _bfd_elf_is_local_label_name (abfd, sym->name);
   12675 }
   12676 
   12677 /* MIPS ELF uses a special find_nearest_line routine in order the
   12678    handle the ECOFF debugging information.  */
   12679 
   12680 struct mips_elf_find_line
   12681 {
   12682   struct ecoff_debug_info d;
   12683   struct ecoff_find_line i;
   12684 };
   12685 
   12686 bfd_boolean
   12687 _bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols,
   12688 				 asection *section, bfd_vma offset,
   12689 				 const char **filename_ptr,
   12690 				 const char **functionname_ptr,
   12691 				 unsigned int *line_ptr,
   12692 				 unsigned int *discriminator_ptr)
   12693 {
   12694   asection *msec;
   12695 
   12696   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
   12697 				     filename_ptr, functionname_ptr,
   12698 				     line_ptr, discriminator_ptr,
   12699 				     dwarf_debug_sections,
   12700 				     ABI_64_P (abfd) ? 8 : 0,
   12701 				     &elf_tdata (abfd)->dwarf2_find_line_info))
   12702     return TRUE;
   12703 
   12704   if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
   12705 				     filename_ptr, functionname_ptr,
   12706 				     line_ptr))
   12707     return TRUE;
   12708 
   12709   msec = bfd_get_section_by_name (abfd, ".mdebug");
   12710   if (msec != NULL)
   12711     {
   12712       flagword origflags;
   12713       struct mips_elf_find_line *fi;
   12714       const struct ecoff_debug_swap * const swap =
   12715 	get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
   12716 
   12717       /* If we are called during a link, mips_elf_final_link may have
   12718 	 cleared the SEC_HAS_CONTENTS field.  We force it back on here
   12719 	 if appropriate (which it normally will be).  */
   12720       origflags = msec->flags;
   12721       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
   12722 	msec->flags |= SEC_HAS_CONTENTS;
   12723 
   12724       fi = mips_elf_tdata (abfd)->find_line_info;
   12725       if (fi == NULL)
   12726 	{
   12727 	  bfd_size_type external_fdr_size;
   12728 	  char *fraw_src;
   12729 	  char *fraw_end;
   12730 	  struct fdr *fdr_ptr;
   12731 	  bfd_size_type amt = sizeof (struct mips_elf_find_line);
   12732 
   12733 	  fi = bfd_zalloc (abfd, amt);
   12734 	  if (fi == NULL)
   12735 	    {
   12736 	      msec->flags = origflags;
   12737 	      return FALSE;
   12738 	    }
   12739 
   12740 	  if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
   12741 	    {
   12742 	      msec->flags = origflags;
   12743 	      return FALSE;
   12744 	    }
   12745 
   12746 	  /* Swap in the FDR information.  */
   12747 	  amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
   12748 	  fi->d.fdr = bfd_alloc (abfd, amt);
   12749 	  if (fi->d.fdr == NULL)
   12750 	    {
   12751 	      msec->flags = origflags;
   12752 	      return FALSE;
   12753 	    }
   12754 	  external_fdr_size = swap->external_fdr_size;
   12755 	  fdr_ptr = fi->d.fdr;
   12756 	  fraw_src = (char *) fi->d.external_fdr;
   12757 	  fraw_end = (fraw_src
   12758 		      + fi->d.symbolic_header.ifdMax * external_fdr_size);
   12759 	  for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
   12760 	    (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
   12761 
   12762 	  mips_elf_tdata (abfd)->find_line_info = fi;
   12763 
   12764 	  /* Note that we don't bother to ever free this information.
   12765              find_nearest_line is either called all the time, as in
   12766              objdump -l, so the information should be saved, or it is
   12767              rarely called, as in ld error messages, so the memory
   12768              wasted is unimportant.  Still, it would probably be a
   12769              good idea for free_cached_info to throw it away.  */
   12770 	}
   12771 
   12772       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
   12773 				  &fi->i, filename_ptr, functionname_ptr,
   12774 				  line_ptr))
   12775 	{
   12776 	  msec->flags = origflags;
   12777 	  return TRUE;
   12778 	}
   12779 
   12780       msec->flags = origflags;
   12781     }
   12782 
   12783   /* Fall back on the generic ELF find_nearest_line routine.  */
   12784 
   12785   return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
   12786 				     filename_ptr, functionname_ptr,
   12787 				     line_ptr, discriminator_ptr);
   12788 }
   12789 
   12790 bfd_boolean
   12791 _bfd_mips_elf_find_inliner_info (bfd *abfd,
   12792 				 const char **filename_ptr,
   12793 				 const char **functionname_ptr,
   12794 				 unsigned int *line_ptr)
   12795 {
   12796   bfd_boolean found;
   12797   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
   12798 					 functionname_ptr, line_ptr,
   12799 					 & elf_tdata (abfd)->dwarf2_find_line_info);
   12800   return found;
   12801 }
   12802 
   12803 
   12804 /* When are writing out the .options or .MIPS.options section,
   12806    remember the bytes we are writing out, so that we can install the
   12807    GP value in the section_processing routine.  */
   12808 
   12809 bfd_boolean
   12810 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
   12811 				    const void *location,
   12812 				    file_ptr offset, bfd_size_type count)
   12813 {
   12814   if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
   12815     {
   12816       bfd_byte *c;
   12817 
   12818       if (elf_section_data (section) == NULL)
   12819 	{
   12820 	  bfd_size_type amt = sizeof (struct bfd_elf_section_data);
   12821 	  section->used_by_bfd = bfd_zalloc (abfd, amt);
   12822 	  if (elf_section_data (section) == NULL)
   12823 	    return FALSE;
   12824 	}
   12825       c = mips_elf_section_data (section)->u.tdata;
   12826       if (c == NULL)
   12827 	{
   12828 	  c = bfd_zalloc (abfd, section->size);
   12829 	  if (c == NULL)
   12830 	    return FALSE;
   12831 	  mips_elf_section_data (section)->u.tdata = c;
   12832 	}
   12833 
   12834       memcpy (c + offset, location, count);
   12835     }
   12836 
   12837   return _bfd_elf_set_section_contents (abfd, section, location, offset,
   12838 					count);
   12839 }
   12840 
   12841 /* This is almost identical to bfd_generic_get_... except that some
   12842    MIPS relocations need to be handled specially.  Sigh.  */
   12843 
   12844 bfd_byte *
   12845 _bfd_elf_mips_get_relocated_section_contents
   12846   (bfd *abfd,
   12847    struct bfd_link_info *link_info,
   12848    struct bfd_link_order *link_order,
   12849    bfd_byte *data,
   12850    bfd_boolean relocatable,
   12851    asymbol **symbols)
   12852 {
   12853   /* Get enough memory to hold the stuff */
   12854   bfd *input_bfd = link_order->u.indirect.section->owner;
   12855   asection *input_section = link_order->u.indirect.section;
   12856   bfd_size_type sz;
   12857 
   12858   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
   12859   arelent **reloc_vector = NULL;
   12860   long reloc_count;
   12861 
   12862   if (reloc_size < 0)
   12863     goto error_return;
   12864 
   12865   reloc_vector = bfd_malloc (reloc_size);
   12866   if (reloc_vector == NULL && reloc_size != 0)
   12867     goto error_return;
   12868 
   12869   /* read in the section */
   12870   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
   12871   if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
   12872     goto error_return;
   12873 
   12874   reloc_count = bfd_canonicalize_reloc (input_bfd,
   12875 					input_section,
   12876 					reloc_vector,
   12877 					symbols);
   12878   if (reloc_count < 0)
   12879     goto error_return;
   12880 
   12881   if (reloc_count > 0)
   12882     {
   12883       arelent **parent;
   12884       /* for mips */
   12885       int gp_found;
   12886       bfd_vma gp = 0x12345678;	/* initialize just to shut gcc up */
   12887 
   12888       {
   12889 	struct bfd_hash_entry *h;
   12890 	struct bfd_link_hash_entry *lh;
   12891 	/* Skip all this stuff if we aren't mixing formats.  */
   12892 	if (abfd && input_bfd
   12893 	    && abfd->xvec == input_bfd->xvec)
   12894 	  lh = 0;
   12895 	else
   12896 	  {
   12897 	    h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
   12898 	    lh = (struct bfd_link_hash_entry *) h;
   12899 	  }
   12900       lookup:
   12901 	if (lh)
   12902 	  {
   12903 	    switch (lh->type)
   12904 	      {
   12905 	      case bfd_link_hash_undefined:
   12906 	      case bfd_link_hash_undefweak:
   12907 	      case bfd_link_hash_common:
   12908 		gp_found = 0;
   12909 		break;
   12910 	      case bfd_link_hash_defined:
   12911 	      case bfd_link_hash_defweak:
   12912 		gp_found = 1;
   12913 		gp = lh->u.def.value;
   12914 		break;
   12915 	      case bfd_link_hash_indirect:
   12916 	      case bfd_link_hash_warning:
   12917 		lh = lh->u.i.link;
   12918 		/* @@FIXME  ignoring warning for now */
   12919 		goto lookup;
   12920 	      case bfd_link_hash_new:
   12921 	      default:
   12922 		abort ();
   12923 	      }
   12924 	  }
   12925 	else
   12926 	  gp_found = 0;
   12927       }
   12928       /* end mips */
   12929       for (parent = reloc_vector; *parent != NULL; parent++)
   12930 	{
   12931 	  char *error_message = NULL;
   12932 	  bfd_reloc_status_type r;
   12933 
   12934 	  /* Specific to MIPS: Deal with relocation types that require
   12935 	     knowing the gp of the output bfd.  */
   12936 	  asymbol *sym = *(*parent)->sym_ptr_ptr;
   12937 
   12938 	  /* If we've managed to find the gp and have a special
   12939 	     function for the relocation then go ahead, else default
   12940 	     to the generic handling.  */
   12941 	  if (gp_found
   12942 	      && (*parent)->howto->special_function
   12943 	      == _bfd_mips_elf32_gprel16_reloc)
   12944 	    r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
   12945 					       input_section, relocatable,
   12946 					       data, gp);
   12947 	  else
   12948 	    r = bfd_perform_relocation (input_bfd, *parent, data,
   12949 					input_section,
   12950 					relocatable ? abfd : NULL,
   12951 					&error_message);
   12952 
   12953 	  if (relocatable)
   12954 	    {
   12955 	      asection *os = input_section->output_section;
   12956 
   12957 	      /* A partial link, so keep the relocs */
   12958 	      os->orelocation[os->reloc_count] = *parent;
   12959 	      os->reloc_count++;
   12960 	    }
   12961 
   12962 	  if (r != bfd_reloc_ok)
   12963 	    {
   12964 	      switch (r)
   12965 		{
   12966 		case bfd_reloc_undefined:
   12967 		  if (!((*link_info->callbacks->undefined_symbol)
   12968 			(link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
   12969 			 input_bfd, input_section, (*parent)->address, TRUE)))
   12970 		    goto error_return;
   12971 		  break;
   12972 		case bfd_reloc_dangerous:
   12973 		  BFD_ASSERT (error_message != NULL);
   12974 		  if (!((*link_info->callbacks->reloc_dangerous)
   12975 			(link_info, error_message, input_bfd, input_section,
   12976 			 (*parent)->address)))
   12977 		    goto error_return;
   12978 		  break;
   12979 		case bfd_reloc_overflow:
   12980 		  if (!((*link_info->callbacks->reloc_overflow)
   12981 			(link_info, NULL,
   12982 			 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
   12983 			 (*parent)->howto->name, (*parent)->addend,
   12984 			 input_bfd, input_section, (*parent)->address)))
   12985 		    goto error_return;
   12986 		  break;
   12987 		case bfd_reloc_outofrange:
   12988 		default:
   12989 		  abort ();
   12990 		  break;
   12991 		}
   12992 
   12993 	    }
   12994 	}
   12995     }
   12996   if (reloc_vector != NULL)
   12997     free (reloc_vector);
   12998   return data;
   12999 
   13000 error_return:
   13001   if (reloc_vector != NULL)
   13002     free (reloc_vector);
   13003   return NULL;
   13004 }
   13005 
   13006 static bfd_boolean
   13008 mips_elf_relax_delete_bytes (bfd *abfd,
   13009 			     asection *sec, bfd_vma addr, int count)
   13010 {
   13011   Elf_Internal_Shdr *symtab_hdr;
   13012   unsigned int sec_shndx;
   13013   bfd_byte *contents;
   13014   Elf_Internal_Rela *irel, *irelend;
   13015   Elf_Internal_Sym *isym;
   13016   Elf_Internal_Sym *isymend;
   13017   struct elf_link_hash_entry **sym_hashes;
   13018   struct elf_link_hash_entry **end_hashes;
   13019   struct elf_link_hash_entry **start_hashes;
   13020   unsigned int symcount;
   13021 
   13022   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
   13023   contents = elf_section_data (sec)->this_hdr.contents;
   13024 
   13025   irel = elf_section_data (sec)->relocs;
   13026   irelend = irel + sec->reloc_count;
   13027 
   13028   /* Actually delete the bytes.  */
   13029   memmove (contents + addr, contents + addr + count,
   13030 	   (size_t) (sec->size - addr - count));
   13031   sec->size -= count;
   13032 
   13033   /* Adjust all the relocs.  */
   13034   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
   13035     {
   13036       /* Get the new reloc address.  */
   13037       if (irel->r_offset > addr)
   13038 	irel->r_offset -= count;
   13039     }
   13040 
   13041   BFD_ASSERT (addr % 2 == 0);
   13042   BFD_ASSERT (count % 2 == 0);
   13043 
   13044   /* Adjust the local symbols defined in this section.  */
   13045   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   13046   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
   13047   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
   13048     if (isym->st_shndx == sec_shndx && isym->st_value > addr)
   13049       isym->st_value -= count;
   13050 
   13051   /* Now adjust the global symbols defined in this section.  */
   13052   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
   13053 	      - symtab_hdr->sh_info);
   13054   sym_hashes = start_hashes = elf_sym_hashes (abfd);
   13055   end_hashes = sym_hashes + symcount;
   13056 
   13057   for (; sym_hashes < end_hashes; sym_hashes++)
   13058     {
   13059       struct elf_link_hash_entry *sym_hash = *sym_hashes;
   13060 
   13061       if ((sym_hash->root.type == bfd_link_hash_defined
   13062 	   || sym_hash->root.type == bfd_link_hash_defweak)
   13063 	  && sym_hash->root.u.def.section == sec)
   13064 	{
   13065 	  bfd_vma value = sym_hash->root.u.def.value;
   13066 
   13067 	  if (ELF_ST_IS_MICROMIPS (sym_hash->other))
   13068 	    value &= MINUS_TWO;
   13069 	  if (value > addr)
   13070 	    sym_hash->root.u.def.value -= count;
   13071 	}
   13072     }
   13073 
   13074   return TRUE;
   13075 }
   13076 
   13077 
   13078 /* Opcodes needed for microMIPS relaxation as found in
   13079    opcodes/micromips-opc.c.  */
   13080 
   13081 struct opcode_descriptor {
   13082   unsigned long match;
   13083   unsigned long mask;
   13084 };
   13085 
   13086 /* The $ra register aka $31.  */
   13087 
   13088 #define RA 31
   13089 
   13090 /* 32-bit instruction format register fields.  */
   13091 
   13092 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
   13093 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
   13094 
   13095 /* Check if a 5-bit register index can be abbreviated to 3 bits.  */
   13096 
   13097 #define OP16_VALID_REG(r) \
   13098   ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
   13099 
   13100 
   13101 /* 32-bit and 16-bit branches.  */
   13102 
   13103 static const struct opcode_descriptor b_insns_32[] = {
   13104   { /* "b",	"p",		*/ 0x40400000, 0xffff0000 }, /* bgez 0 */
   13105   { /* "b",	"p",		*/ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
   13106   { 0, 0 }  /* End marker for find_match().  */
   13107 };
   13108 
   13109 static const struct opcode_descriptor bc_insn_32 =
   13110   { /* "bc(1|2)(ft)", "N,p",	*/ 0x42800000, 0xfec30000 };
   13111 
   13112 static const struct opcode_descriptor bz_insn_32 =
   13113   { /* "b(g|l)(e|t)z", "s,p",	*/ 0x40000000, 0xff200000 };
   13114 
   13115 static const struct opcode_descriptor bzal_insn_32 =
   13116   { /* "b(ge|lt)zal", "s,p",	*/ 0x40200000, 0xffa00000 };
   13117 
   13118 static const struct opcode_descriptor beq_insn_32 =
   13119   { /* "b(eq|ne)", "s,t,p",	*/ 0x94000000, 0xdc000000 };
   13120 
   13121 static const struct opcode_descriptor b_insn_16 =
   13122   { /* "b",	"mD",		*/ 0xcc00,     0xfc00 };
   13123 
   13124 static const struct opcode_descriptor bz_insn_16 =
   13125   { /* "b(eq|ne)z", "md,mE",	*/ 0x8c00,     0xdc00 };
   13126 
   13127 
   13128 /* 32-bit and 16-bit branch EQ and NE zero.  */
   13129 
   13130 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
   13131    eq and second the ne.  This convention is used when replacing a
   13132    32-bit BEQ/BNE with the 16-bit version.  */
   13133 
   13134 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
   13135 
   13136 static const struct opcode_descriptor bz_rs_insns_32[] = {
   13137   { /* "beqz",	"s,p",		*/ 0x94000000, 0xffe00000 },
   13138   { /* "bnez",	"s,p",		*/ 0xb4000000, 0xffe00000 },
   13139   { 0, 0 }  /* End marker for find_match().  */
   13140 };
   13141 
   13142 static const struct opcode_descriptor bz_rt_insns_32[] = {
   13143   { /* "beqz",	"t,p",		*/ 0x94000000, 0xfc01f000 },
   13144   { /* "bnez",	"t,p",		*/ 0xb4000000, 0xfc01f000 },
   13145   { 0, 0 }  /* End marker for find_match().  */
   13146 };
   13147 
   13148 static const struct opcode_descriptor bzc_insns_32[] = {
   13149   { /* "beqzc",	"s,p",		*/ 0x40e00000, 0xffe00000 },
   13150   { /* "bnezc",	"s,p",		*/ 0x40a00000, 0xffe00000 },
   13151   { 0, 0 }  /* End marker for find_match().  */
   13152 };
   13153 
   13154 static const struct opcode_descriptor bz_insns_16[] = {
   13155   { /* "beqz",	"md,mE",	*/ 0x8c00,     0xfc00 },
   13156   { /* "bnez",	"md,mE",	*/ 0xac00,     0xfc00 },
   13157   { 0, 0 }  /* End marker for find_match().  */
   13158 };
   13159 
   13160 /* Switch between a 5-bit register index and its 3-bit shorthand.  */
   13161 
   13162 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
   13163 #define BZ16_REG_FIELD(r) \
   13164   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
   13165 
   13166 
   13167 /* 32-bit instructions with a delay slot.  */
   13168 
   13169 static const struct opcode_descriptor jal_insn_32_bd16 =
   13170   { /* "jals",	"a",		*/ 0x74000000, 0xfc000000 };
   13171 
   13172 static const struct opcode_descriptor jal_insn_32_bd32 =
   13173   { /* "jal",	"a",		*/ 0xf4000000, 0xfc000000 };
   13174 
   13175 static const struct opcode_descriptor jal_x_insn_32_bd32 =
   13176   { /* "jal[x]", "a",		*/ 0xf0000000, 0xf8000000 };
   13177 
   13178 static const struct opcode_descriptor j_insn_32 =
   13179   { /* "j",	"a",		*/ 0xd4000000, 0xfc000000 };
   13180 
   13181 static const struct opcode_descriptor jalr_insn_32 =
   13182   { /* "jalr[.hb]", "t,s",	*/ 0x00000f3c, 0xfc00efff };
   13183 
   13184 /* This table can be compacted, because no opcode replacement is made.  */
   13185 
   13186 static const struct opcode_descriptor ds_insns_32_bd16[] = {
   13187   { /* "jals",	"a",		*/ 0x74000000, 0xfc000000 },
   13188 
   13189   { /* "jalrs[.hb]", "t,s",	*/ 0x00004f3c, 0xfc00efff },
   13190   { /* "b(ge|lt)zals", "s,p",	*/ 0x42200000, 0xffa00000 },
   13191 
   13192   { /* "b(g|l)(e|t)z", "s,p",	*/ 0x40000000, 0xff200000 },
   13193   { /* "b(eq|ne)", "s,t,p",	*/ 0x94000000, 0xdc000000 },
   13194   { /* "j",	"a",		*/ 0xd4000000, 0xfc000000 },
   13195   { 0, 0 }  /* End marker for find_match().  */
   13196 };
   13197 
   13198 /* This table can be compacted, because no opcode replacement is made.  */
   13199 
   13200 static const struct opcode_descriptor ds_insns_32_bd32[] = {
   13201   { /* "jal[x]", "a",		*/ 0xf0000000, 0xf8000000 },
   13202 
   13203   { /* "jalr[.hb]", "t,s",	*/ 0x00000f3c, 0xfc00efff },
   13204   { /* "b(ge|lt)zal", "s,p",	*/ 0x40200000, 0xffa00000 },
   13205   { 0, 0 }  /* End marker for find_match().  */
   13206 };
   13207 
   13208 
   13209 /* 16-bit instructions with a delay slot.  */
   13210 
   13211 static const struct opcode_descriptor jalr_insn_16_bd16 =
   13212   { /* "jalrs",	"my,mj",	*/ 0x45e0,     0xffe0 };
   13213 
   13214 static const struct opcode_descriptor jalr_insn_16_bd32 =
   13215   { /* "jalr",	"my,mj",	*/ 0x45c0,     0xffe0 };
   13216 
   13217 static const struct opcode_descriptor jr_insn_16 =
   13218   { /* "jr",	"mj",		*/ 0x4580,     0xffe0 };
   13219 
   13220 #define JR16_REG(opcode) ((opcode) & 0x1f)
   13221 
   13222 /* This table can be compacted, because no opcode replacement is made.  */
   13223 
   13224 static const struct opcode_descriptor ds_insns_16_bd16[] = {
   13225   { /* "jalrs",	"my,mj",	*/ 0x45e0,     0xffe0 },
   13226 
   13227   { /* "b",	"mD",		*/ 0xcc00,     0xfc00 },
   13228   { /* "b(eq|ne)z", "md,mE",	*/ 0x8c00,     0xdc00 },
   13229   { /* "jr",	"mj",		*/ 0x4580,     0xffe0 },
   13230   { 0, 0 }  /* End marker for find_match().  */
   13231 };
   13232 
   13233 
   13234 /* LUI instruction.  */
   13235 
   13236 static const struct opcode_descriptor lui_insn =
   13237  { /* "lui",	"s,u",		*/ 0x41a00000, 0xffe00000 };
   13238 
   13239 
   13240 /* ADDIU instruction.  */
   13241 
   13242 static const struct opcode_descriptor addiu_insn =
   13243   { /* "addiu",	"t,r,j",	*/ 0x30000000, 0xfc000000 };
   13244 
   13245 static const struct opcode_descriptor addiupc_insn =
   13246   { /* "addiu",	"mb,$pc,mQ",	*/ 0x78000000, 0xfc000000 };
   13247 
   13248 #define ADDIUPC_REG_FIELD(r) \
   13249   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
   13250 
   13251 
   13252 /* Relaxable instructions in a JAL delay slot: MOVE.  */
   13253 
   13254 /* The 16-bit move has rd in 9:5 and rs in 4:0.  The 32-bit moves
   13255    (ADDU, OR) have rd in 15:11 and rs in 10:16.  */
   13256 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
   13257 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
   13258 
   13259 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
   13260 #define MOVE16_RS_FIELD(r) (((r) & 0x1f)     )
   13261 
   13262 static const struct opcode_descriptor move_insns_32[] = {
   13263   { /* "move",	"d,s",		*/ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
   13264   { /* "move",	"d,s",		*/ 0x00000290, 0xffe007ff }, /* or   d,s,$0 */
   13265   { 0, 0 }  /* End marker for find_match().  */
   13266 };
   13267 
   13268 static const struct opcode_descriptor move_insn_16 =
   13269   { /* "move",	"mp,mj",	*/ 0x0c00,     0xfc00 };
   13270 
   13271 
   13272 /* NOP instructions.  */
   13273 
   13274 static const struct opcode_descriptor nop_insn_32 =
   13275   { /* "nop",	"",		*/ 0x00000000, 0xffffffff };
   13276 
   13277 static const struct opcode_descriptor nop_insn_16 =
   13278   { /* "nop",	"",		*/ 0x0c00,     0xffff };
   13279 
   13280 
   13281 /* Instruction match support.  */
   13282 
   13283 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
   13284 
   13285 static int
   13286 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
   13287 {
   13288   unsigned long indx;
   13289 
   13290   for (indx = 0; insn[indx].mask != 0; indx++)
   13291     if (MATCH (opcode, insn[indx]))
   13292       return indx;
   13293 
   13294   return -1;
   13295 }
   13296 
   13297 
   13298 /* Branch and delay slot decoding support.  */
   13299 
   13300 /* If PTR points to what *might* be a 16-bit branch or jump, then
   13301    return the minimum length of its delay slot, otherwise return 0.
   13302    Non-zero results are not definitive as we might be checking against
   13303    the second half of another instruction.  */
   13304 
   13305 static int
   13306 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
   13307 {
   13308   unsigned long opcode;
   13309   int bdsize;
   13310 
   13311   opcode = bfd_get_16 (abfd, ptr);
   13312   if (MATCH (opcode, jalr_insn_16_bd32) != 0)
   13313     /* 16-bit branch/jump with a 32-bit delay slot.  */
   13314     bdsize = 4;
   13315   else if (MATCH (opcode, jalr_insn_16_bd16) != 0
   13316 	   || find_match (opcode, ds_insns_16_bd16) >= 0)
   13317     /* 16-bit branch/jump with a 16-bit delay slot.  */
   13318     bdsize = 2;
   13319   else
   13320     /* No delay slot.  */
   13321     bdsize = 0;
   13322 
   13323   return bdsize;
   13324 }
   13325 
   13326 /* If PTR points to what *might* be a 32-bit branch or jump, then
   13327    return the minimum length of its delay slot, otherwise return 0.
   13328    Non-zero results are not definitive as we might be checking against
   13329    the second half of another instruction.  */
   13330 
   13331 static int
   13332 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
   13333 {
   13334   unsigned long opcode;
   13335   int bdsize;
   13336 
   13337   opcode = bfd_get_micromips_32 (abfd, ptr);
   13338   if (find_match (opcode, ds_insns_32_bd32) >= 0)
   13339     /* 32-bit branch/jump with a 32-bit delay slot.  */
   13340     bdsize = 4;
   13341   else if (find_match (opcode, ds_insns_32_bd16) >= 0)
   13342     /* 32-bit branch/jump with a 16-bit delay slot.  */
   13343     bdsize = 2;
   13344   else
   13345     /* No delay slot.  */
   13346     bdsize = 0;
   13347 
   13348   return bdsize;
   13349 }
   13350 
   13351 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
   13352    that doesn't fiddle with REG, then return TRUE, otherwise FALSE.  */
   13353 
   13354 static bfd_boolean
   13355 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
   13356 {
   13357   unsigned long opcode;
   13358 
   13359   opcode = bfd_get_16 (abfd, ptr);
   13360   if (MATCH (opcode, b_insn_16)
   13361 						/* B16  */
   13362       || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
   13363 						/* JR16  */
   13364       || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
   13365 						/* BEQZ16, BNEZ16  */
   13366       || (MATCH (opcode, jalr_insn_16_bd32)
   13367 						/* JALR16  */
   13368 	  && reg != JR16_REG (opcode) && reg != RA))
   13369     return TRUE;
   13370 
   13371   return FALSE;
   13372 }
   13373 
   13374 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
   13375    then return TRUE, otherwise FALSE.  */
   13376 
   13377 static bfd_boolean
   13378 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
   13379 {
   13380   unsigned long opcode;
   13381 
   13382   opcode = bfd_get_micromips_32 (abfd, ptr);
   13383   if (MATCH (opcode, j_insn_32)
   13384 						/* J  */
   13385       || MATCH (opcode, bc_insn_32)
   13386 						/* BC1F, BC1T, BC2F, BC2T  */
   13387       || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
   13388 						/* JAL, JALX  */
   13389       || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
   13390 						/* BGEZ, BGTZ, BLEZ, BLTZ  */
   13391       || (MATCH (opcode, bzal_insn_32)
   13392 						/* BGEZAL, BLTZAL  */
   13393 	  && reg != OP32_SREG (opcode) && reg != RA)
   13394       || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
   13395 						/* JALR, JALR.HB, BEQ, BNE  */
   13396 	  && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
   13397     return TRUE;
   13398 
   13399   return FALSE;
   13400 }
   13401 
   13402 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
   13403    IRELEND) at OFFSET indicate that there must be a compact branch there,
   13404    then return TRUE, otherwise FALSE.  */
   13405 
   13406 static bfd_boolean
   13407 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
   13408 		     const Elf_Internal_Rela *internal_relocs,
   13409 		     const Elf_Internal_Rela *irelend)
   13410 {
   13411   const Elf_Internal_Rela *irel;
   13412   unsigned long opcode;
   13413 
   13414   opcode = bfd_get_micromips_32 (abfd, ptr);
   13415   if (find_match (opcode, bzc_insns_32) < 0)
   13416     return FALSE;
   13417 
   13418   for (irel = internal_relocs; irel < irelend; irel++)
   13419     if (irel->r_offset == offset
   13420 	&& ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
   13421       return TRUE;
   13422 
   13423   return FALSE;
   13424 }
   13425 
   13426 /* Bitsize checking.  */
   13427 #define IS_BITSIZE(val, N)						\
   13428   (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1)))		\
   13429     - (1ULL << ((N) - 1))) == (val))
   13430 
   13431 
   13432 bfd_boolean
   13434 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
   13435 			     struct bfd_link_info *link_info,
   13436 			     bfd_boolean *again)
   13437 {
   13438   bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32;
   13439   Elf_Internal_Shdr *symtab_hdr;
   13440   Elf_Internal_Rela *internal_relocs;
   13441   Elf_Internal_Rela *irel, *irelend;
   13442   bfd_byte *contents = NULL;
   13443   Elf_Internal_Sym *isymbuf = NULL;
   13444 
   13445   /* Assume nothing changes.  */
   13446   *again = FALSE;
   13447 
   13448   /* We don't have to do anything for a relocatable link, if
   13449      this section does not have relocs, or if this is not a
   13450      code section.  */
   13451 
   13452   if (link_info->relocatable
   13453       || (sec->flags & SEC_RELOC) == 0
   13454       || sec->reloc_count == 0
   13455       || (sec->flags & SEC_CODE) == 0)
   13456     return TRUE;
   13457 
   13458   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   13459 
   13460   /* Get a copy of the native relocations.  */
   13461   internal_relocs = (_bfd_elf_link_read_relocs
   13462 		     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
   13463 		      link_info->keep_memory));
   13464   if (internal_relocs == NULL)
   13465     goto error_return;
   13466 
   13467   /* Walk through them looking for relaxing opportunities.  */
   13468   irelend = internal_relocs + sec->reloc_count;
   13469   for (irel = internal_relocs; irel < irelend; irel++)
   13470     {
   13471       unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
   13472       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
   13473       bfd_boolean target_is_micromips_code_p;
   13474       unsigned long opcode;
   13475       bfd_vma symval;
   13476       bfd_vma pcrval;
   13477       bfd_byte *ptr;
   13478       int fndopc;
   13479 
   13480       /* The number of bytes to delete for relaxation and from where
   13481          to delete these bytes starting at irel->r_offset.  */
   13482       int delcnt = 0;
   13483       int deloff = 0;
   13484 
   13485       /* If this isn't something that can be relaxed, then ignore
   13486          this reloc.  */
   13487       if (r_type != R_MICROMIPS_HI16
   13488 	  && r_type != R_MICROMIPS_PC16_S1
   13489 	  && r_type != R_MICROMIPS_26_S1)
   13490 	continue;
   13491 
   13492       /* Get the section contents if we haven't done so already.  */
   13493       if (contents == NULL)
   13494 	{
   13495 	  /* Get cached copy if it exists.  */
   13496 	  if (elf_section_data (sec)->this_hdr.contents != NULL)
   13497 	    contents = elf_section_data (sec)->this_hdr.contents;
   13498 	  /* Go get them off disk.  */
   13499 	  else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
   13500 	    goto error_return;
   13501 	}
   13502       ptr = contents + irel->r_offset;
   13503 
   13504       /* Read this BFD's local symbols if we haven't done so already.  */
   13505       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
   13506 	{
   13507 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
   13508 	  if (isymbuf == NULL)
   13509 	    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
   13510 					    symtab_hdr->sh_info, 0,
   13511 					    NULL, NULL, NULL);
   13512 	  if (isymbuf == NULL)
   13513 	    goto error_return;
   13514 	}
   13515 
   13516       /* Get the value of the symbol referred to by the reloc.  */
   13517       if (r_symndx < symtab_hdr->sh_info)
   13518 	{
   13519 	  /* A local symbol.  */
   13520 	  Elf_Internal_Sym *isym;
   13521 	  asection *sym_sec;
   13522 
   13523 	  isym = isymbuf + r_symndx;
   13524 	  if (isym->st_shndx == SHN_UNDEF)
   13525 	    sym_sec = bfd_und_section_ptr;
   13526 	  else if (isym->st_shndx == SHN_ABS)
   13527 	    sym_sec = bfd_abs_section_ptr;
   13528 	  else if (isym->st_shndx == SHN_COMMON)
   13529 	    sym_sec = bfd_com_section_ptr;
   13530 	  else
   13531 	    sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
   13532 	  symval = (isym->st_value
   13533 		    + sym_sec->output_section->vma
   13534 		    + sym_sec->output_offset);
   13535 	  target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
   13536 	}
   13537       else
   13538 	{
   13539 	  unsigned long indx;
   13540 	  struct elf_link_hash_entry *h;
   13541 
   13542 	  /* An external symbol.  */
   13543 	  indx = r_symndx - symtab_hdr->sh_info;
   13544 	  h = elf_sym_hashes (abfd)[indx];
   13545 	  BFD_ASSERT (h != NULL);
   13546 
   13547 	  if (h->root.type != bfd_link_hash_defined
   13548 	      && h->root.type != bfd_link_hash_defweak)
   13549 	    /* This appears to be a reference to an undefined
   13550 	       symbol.  Just ignore it -- it will be caught by the
   13551 	       regular reloc processing.  */
   13552 	    continue;
   13553 
   13554 	  symval = (h->root.u.def.value
   13555 		    + h->root.u.def.section->output_section->vma
   13556 		    + h->root.u.def.section->output_offset);
   13557 	  target_is_micromips_code_p = (!h->needs_plt
   13558 					&& ELF_ST_IS_MICROMIPS (h->other));
   13559 	}
   13560 
   13561 
   13562       /* For simplicity of coding, we are going to modify the
   13563          section contents, the section relocs, and the BFD symbol
   13564          table.  We must tell the rest of the code not to free up this
   13565          information.  It would be possible to instead create a table
   13566          of changes which have to be made, as is done in coff-mips.c;
   13567          that would be more work, but would require less memory when
   13568          the linker is run.  */
   13569 
   13570       /* Only 32-bit instructions relaxed.  */
   13571       if (irel->r_offset + 4 > sec->size)
   13572 	continue;
   13573 
   13574       opcode = bfd_get_micromips_32 (abfd, ptr);
   13575 
   13576       /* This is the pc-relative distance from the instruction the
   13577          relocation is applied to, to the symbol referred.  */
   13578       pcrval = (symval
   13579 		- (sec->output_section->vma + sec->output_offset)
   13580 		- irel->r_offset);
   13581 
   13582       /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
   13583          of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
   13584          R_MICROMIPS_PC23_S2.  The R_MICROMIPS_PC23_S2 condition is
   13585 
   13586            (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
   13587 
   13588          where pcrval has first to be adjusted to apply against the LO16
   13589          location (we make the adjustment later on, when we have figured
   13590          out the offset).  */
   13591       if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
   13592 	{
   13593 	  bfd_boolean bzc = FALSE;
   13594 	  unsigned long nextopc;
   13595 	  unsigned long reg;
   13596 	  bfd_vma offset;
   13597 
   13598 	  /* Give up if the previous reloc was a HI16 against this symbol
   13599 	     too.  */
   13600 	  if (irel > internal_relocs
   13601 	      && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
   13602 	      && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
   13603 	    continue;
   13604 
   13605 	  /* Or if the next reloc is not a LO16 against this symbol.  */
   13606 	  if (irel + 1 >= irelend
   13607 	      || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
   13608 	      || ELF32_R_SYM (irel[1].r_info) != r_symndx)
   13609 	    continue;
   13610 
   13611 	  /* Or if the second next reloc is a LO16 against this symbol too.  */
   13612 	  if (irel + 2 >= irelend
   13613 	      && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
   13614 	      && ELF32_R_SYM (irel[2].r_info) == r_symndx)
   13615 	    continue;
   13616 
   13617 	  /* See if the LUI instruction *might* be in a branch delay slot.
   13618 	     We check whether what looks like a 16-bit branch or jump is
   13619 	     actually an immediate argument to a compact branch, and let
   13620 	     it through if so.  */
   13621 	  if (irel->r_offset >= 2
   13622 	      && check_br16_dslot (abfd, ptr - 2)
   13623 	      && !(irel->r_offset >= 4
   13624 		   && (bzc = check_relocated_bzc (abfd,
   13625 						  ptr - 4, irel->r_offset - 4,
   13626 						  internal_relocs, irelend))))
   13627 	    continue;
   13628 	  if (irel->r_offset >= 4
   13629 	      && !bzc
   13630 	      && check_br32_dslot (abfd, ptr - 4))
   13631 	    continue;
   13632 
   13633 	  reg = OP32_SREG (opcode);
   13634 
   13635 	  /* We only relax adjacent instructions or ones separated with
   13636 	     a branch or jump that has a delay slot.  The branch or jump
   13637 	     must not fiddle with the register used to hold the address.
   13638 	     Subtract 4 for the LUI itself.  */
   13639 	  offset = irel[1].r_offset - irel[0].r_offset;
   13640 	  switch (offset - 4)
   13641 	    {
   13642 	    case 0:
   13643 	      break;
   13644 	    case 2:
   13645 	      if (check_br16 (abfd, ptr + 4, reg))
   13646 		break;
   13647 	      continue;
   13648 	    case 4:
   13649 	      if (check_br32 (abfd, ptr + 4, reg))
   13650 		break;
   13651 	      continue;
   13652 	    default:
   13653 	      continue;
   13654 	    }
   13655 
   13656 	  nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
   13657 
   13658 	  /* Give up unless the same register is used with both
   13659 	     relocations.  */
   13660 	  if (OP32_SREG (nextopc) != reg)
   13661 	    continue;
   13662 
   13663 	  /* Now adjust pcrval, subtracting the offset to the LO16 reloc
   13664 	     and rounding up to take masking of the two LSBs into account.  */
   13665 	  pcrval = ((pcrval - offset + 3) | 3) ^ 3;
   13666 
   13667 	  /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16.  */
   13668 	  if (IS_BITSIZE (symval, 16))
   13669 	    {
   13670 	      /* Fix the relocation's type.  */
   13671 	      irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
   13672 
   13673 	      /* Instructions using R_MICROMIPS_LO16 have the base or
   13674 	         source register in bits 20:16.  This register becomes $0
   13675 	         (zero) as the result of the R_MICROMIPS_HI16 being 0.  */
   13676 	      nextopc &= ~0x001f0000;
   13677 	      bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
   13678 			  contents + irel[1].r_offset);
   13679 	    }
   13680 
   13681 	  /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
   13682 	     We add 4 to take LUI deletion into account while checking
   13683 	     the PC-relative distance.  */
   13684 	  else if (symval % 4 == 0
   13685 		   && IS_BITSIZE (pcrval + 4, 25)
   13686 		   && MATCH (nextopc, addiu_insn)
   13687 		   && OP32_TREG (nextopc) == OP32_SREG (nextopc)
   13688 		   && OP16_VALID_REG (OP32_TREG (nextopc)))
   13689 	    {
   13690 	      /* Fix the relocation's type.  */
   13691 	      irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
   13692 
   13693 	      /* Replace ADDIU with the ADDIUPC version.  */
   13694 	      nextopc = (addiupc_insn.match
   13695 			 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
   13696 
   13697 	      bfd_put_micromips_32 (abfd, nextopc,
   13698 				    contents + irel[1].r_offset);
   13699 	    }
   13700 
   13701 	  /* Can't do anything, give up, sigh...  */
   13702 	  else
   13703 	    continue;
   13704 
   13705 	  /* Fix the relocation's type.  */
   13706 	  irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
   13707 
   13708 	  /* Delete the LUI instruction: 4 bytes at irel->r_offset.  */
   13709 	  delcnt = 4;
   13710 	  deloff = 0;
   13711 	}
   13712 
   13713       /* Compact branch relaxation -- due to the multitude of macros
   13714          employed by the compiler/assembler, compact branches are not
   13715          always generated.  Obviously, this can/will be fixed elsewhere,
   13716          but there is no drawback in double checking it here.  */
   13717       else if (r_type == R_MICROMIPS_PC16_S1
   13718 	       && irel->r_offset + 5 < sec->size
   13719 	       && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
   13720 		   || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
   13721 	       && ((!insn32
   13722 		    && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4),
   13723 					nop_insn_16) ? 2 : 0))
   13724 		   || (irel->r_offset + 7 < sec->size
   13725 		       && (delcnt = MATCH (bfd_get_micromips_32 (abfd,
   13726 								 ptr + 4),
   13727 					   nop_insn_32) ? 4 : 0))))
   13728 	{
   13729 	  unsigned long reg;
   13730 
   13731 	  reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
   13732 
   13733 	  /* Replace BEQZ/BNEZ with the compact version.  */
   13734 	  opcode = (bzc_insns_32[fndopc].match
   13735 		    | BZC32_REG_FIELD (reg)
   13736 		    | (opcode & 0xffff));		/* Addend value.  */
   13737 
   13738 	  bfd_put_micromips_32 (abfd, opcode, ptr);
   13739 
   13740 	  /* Delete the delay slot NOP: two or four bytes from
   13741 	     irel->offset + 4; delcnt has already been set above.  */
   13742 	  deloff = 4;
   13743 	}
   13744 
   13745       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1.  We need
   13746          to check the distance from the next instruction, so subtract 2.  */
   13747       else if (!insn32
   13748 	       && r_type == R_MICROMIPS_PC16_S1
   13749 	       && IS_BITSIZE (pcrval - 2, 11)
   13750 	       && find_match (opcode, b_insns_32) >= 0)
   13751 	{
   13752 	  /* Fix the relocation's type.  */
   13753 	  irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
   13754 
   13755 	  /* Replace the 32-bit opcode with a 16-bit opcode.  */
   13756 	  bfd_put_16 (abfd,
   13757 		      (b_insn_16.match
   13758 		       | (opcode & 0x3ff)),		/* Addend value.  */
   13759 		      ptr);
   13760 
   13761 	  /* Delete 2 bytes from irel->r_offset + 2.  */
   13762 	  delcnt = 2;
   13763 	  deloff = 2;
   13764 	}
   13765 
   13766       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1.  We need
   13767          to check the distance from the next instruction, so subtract 2.  */
   13768       else if (!insn32
   13769 	       && r_type == R_MICROMIPS_PC16_S1
   13770 	       && IS_BITSIZE (pcrval - 2, 8)
   13771 	       && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
   13772 		    && OP16_VALID_REG (OP32_SREG (opcode)))
   13773 		   || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
   13774 		       && OP16_VALID_REG (OP32_TREG (opcode)))))
   13775 	{
   13776 	  unsigned long reg;
   13777 
   13778 	  reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
   13779 
   13780 	  /* Fix the relocation's type.  */
   13781 	  irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
   13782 
   13783 	  /* Replace the 32-bit opcode with a 16-bit opcode.  */
   13784 	  bfd_put_16 (abfd,
   13785 		      (bz_insns_16[fndopc].match
   13786 		       | BZ16_REG_FIELD (reg)
   13787 		       | (opcode & 0x7f)),		/* Addend value.  */
   13788 		      ptr);
   13789 
   13790 	  /* Delete 2 bytes from irel->r_offset + 2.  */
   13791 	  delcnt = 2;
   13792 	  deloff = 2;
   13793 	}
   13794 
   13795       /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets.  */
   13796       else if (!insn32
   13797 	       && r_type == R_MICROMIPS_26_S1
   13798 	       && target_is_micromips_code_p
   13799 	       && irel->r_offset + 7 < sec->size
   13800 	       && MATCH (opcode, jal_insn_32_bd32))
   13801 	{
   13802 	  unsigned long n32opc;
   13803 	  bfd_boolean relaxed = FALSE;
   13804 
   13805 	  n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
   13806 
   13807 	  if (MATCH (n32opc, nop_insn_32))
   13808 	    {
   13809 	      /* Replace delay slot 32-bit NOP with a 16-bit NOP.  */
   13810 	      bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
   13811 
   13812 	      relaxed = TRUE;
   13813 	    }
   13814 	  else if (find_match (n32opc, move_insns_32) >= 0)
   13815 	    {
   13816 	      /* Replace delay slot 32-bit MOVE with 16-bit MOVE.  */
   13817 	      bfd_put_16 (abfd,
   13818 			  (move_insn_16.match
   13819 			   | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
   13820 			   | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
   13821 			  ptr + 4);
   13822 
   13823 	      relaxed = TRUE;
   13824 	    }
   13825 	  /* Other 32-bit instructions relaxable to 16-bit
   13826 	     instructions will be handled here later.  */
   13827 
   13828 	  if (relaxed)
   13829 	    {
   13830 	      /* JAL with 32-bit delay slot that is changed to a JALS
   13831 	         with 16-bit delay slot.  */
   13832 	      bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
   13833 
   13834 	      /* Delete 2 bytes from irel->r_offset + 6.  */
   13835 	      delcnt = 2;
   13836 	      deloff = 6;
   13837 	    }
   13838 	}
   13839 
   13840       if (delcnt != 0)
   13841 	{
   13842 	  /* Note that we've changed the relocs, section contents, etc.  */
   13843 	  elf_section_data (sec)->relocs = internal_relocs;
   13844 	  elf_section_data (sec)->this_hdr.contents = contents;
   13845 	  symtab_hdr->contents = (unsigned char *) isymbuf;
   13846 
   13847 	  /* Delete bytes depending on the delcnt and deloff.  */
   13848 	  if (!mips_elf_relax_delete_bytes (abfd, sec,
   13849 					    irel->r_offset + deloff, delcnt))
   13850 	    goto error_return;
   13851 
   13852 	  /* That will change things, so we should relax again.
   13853 	     Note that this is not required, and it may be slow.  */
   13854 	  *again = TRUE;
   13855 	}
   13856     }
   13857 
   13858   if (isymbuf != NULL
   13859       && symtab_hdr->contents != (unsigned char *) isymbuf)
   13860     {
   13861       if (! link_info->keep_memory)
   13862 	free (isymbuf);
   13863       else
   13864 	{
   13865 	  /* Cache the symbols for elf_link_input_bfd.  */
   13866 	  symtab_hdr->contents = (unsigned char *) isymbuf;
   13867 	}
   13868     }
   13869 
   13870   if (contents != NULL
   13871       && elf_section_data (sec)->this_hdr.contents != contents)
   13872     {
   13873       if (! link_info->keep_memory)
   13874 	free (contents);
   13875       else
   13876 	{
   13877 	  /* Cache the section contents for elf_link_input_bfd.  */
   13878 	  elf_section_data (sec)->this_hdr.contents = contents;
   13879 	}
   13880     }
   13881 
   13882   if (internal_relocs != NULL
   13883       && elf_section_data (sec)->relocs != internal_relocs)
   13884     free (internal_relocs);
   13885 
   13886   return TRUE;
   13887 
   13888  error_return:
   13889   if (isymbuf != NULL
   13890       && symtab_hdr->contents != (unsigned char *) isymbuf)
   13891     free (isymbuf);
   13892   if (contents != NULL
   13893       && elf_section_data (sec)->this_hdr.contents != contents)
   13894     free (contents);
   13895   if (internal_relocs != NULL
   13896       && elf_section_data (sec)->relocs != internal_relocs)
   13897     free (internal_relocs);
   13898 
   13899   return FALSE;
   13900 }
   13901 
   13902 /* Create a MIPS ELF linker hash table.  */
   13904 
   13905 struct bfd_link_hash_table *
   13906 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
   13907 {
   13908   struct mips_elf_link_hash_table *ret;
   13909   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
   13910 
   13911   ret = bfd_zmalloc (amt);
   13912   if (ret == NULL)
   13913     return NULL;
   13914 
   13915   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
   13916 				      mips_elf_link_hash_newfunc,
   13917 				      sizeof (struct mips_elf_link_hash_entry),
   13918 				      MIPS_ELF_DATA))
   13919     {
   13920       free (ret);
   13921       return NULL;
   13922     }
   13923   ret->root.init_plt_refcount.plist = NULL;
   13924   ret->root.init_plt_offset.plist = NULL;
   13925 
   13926   return &ret->root.root;
   13927 }
   13928 
   13929 /* Likewise, but indicate that the target is VxWorks.  */
   13930 
   13931 struct bfd_link_hash_table *
   13932 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
   13933 {
   13934   struct bfd_link_hash_table *ret;
   13935 
   13936   ret = _bfd_mips_elf_link_hash_table_create (abfd);
   13937   if (ret)
   13938     {
   13939       struct mips_elf_link_hash_table *htab;
   13940 
   13941       htab = (struct mips_elf_link_hash_table *) ret;
   13942       htab->use_plts_and_copy_relocs = TRUE;
   13943       htab->is_vxworks = TRUE;
   13944     }
   13945   return ret;
   13946 }
   13947 
   13948 /* A function that the linker calls if we are allowed to use PLTs
   13949    and copy relocs.  */
   13950 
   13951 void
   13952 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
   13953 {
   13954   mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
   13955 }
   13956 
   13957 /* A function that the linker calls to select between all or only
   13958    32-bit microMIPS instructions.  */
   13959 
   13960 void
   13961 _bfd_mips_elf_insn32 (struct bfd_link_info *info, bfd_boolean on)
   13962 {
   13963   mips_elf_hash_table (info)->insn32 = on;
   13964 }
   13965 
   13966 void
   13967 _bfd_mips_elf_compact_branches (struct bfd_link_info *info, bfd_boolean on)
   13968 {
   13969   mips_elf_hash_table (info)->compact_branches = on;
   13970 }
   13971 
   13972 
   13973 /* Return the .MIPS.abiflags value representing each ISA Extension.  */
   13975 
   13976 unsigned int
   13977 bfd_mips_isa_ext (bfd *abfd)
   13978 {
   13979   switch (bfd_get_mach (abfd))
   13980     {
   13981     case bfd_mach_mips3900:
   13982       return AFL_EXT_3900;
   13983     case bfd_mach_mips4010:
   13984       return AFL_EXT_4010;
   13985     case bfd_mach_mips4100:
   13986       return AFL_EXT_4100;
   13987     case bfd_mach_mips4111:
   13988       return AFL_EXT_4111;
   13989     case bfd_mach_mips4120:
   13990       return AFL_EXT_4120;
   13991     case bfd_mach_mips4650:
   13992       return AFL_EXT_4650;
   13993     case bfd_mach_mips5400:
   13994       return AFL_EXT_5400;
   13995     case bfd_mach_mips5500:
   13996       return AFL_EXT_5500;
   13997     case bfd_mach_mips5900:
   13998       return AFL_EXT_5900;
   13999     case bfd_mach_mips10000:
   14000       return AFL_EXT_10000;
   14001     case bfd_mach_mips_loongson_2e:
   14002       return AFL_EXT_LOONGSON_2E;
   14003     case bfd_mach_mips_loongson_2f:
   14004       return AFL_EXT_LOONGSON_2F;
   14005     case bfd_mach_mips_loongson_3a:
   14006       return AFL_EXT_LOONGSON_3A;
   14007     case bfd_mach_mips_sb1:
   14008       return AFL_EXT_SB1;
   14009     case bfd_mach_mips_octeon:
   14010       return AFL_EXT_OCTEON;
   14011     case bfd_mach_mips_octeonp:
   14012       return AFL_EXT_OCTEONP;
   14013     case bfd_mach_mips_octeon3:
   14014       return AFL_EXT_OCTEON3;
   14015     case bfd_mach_mips_octeon2:
   14016       return AFL_EXT_OCTEON2;
   14017     case bfd_mach_mips_xlr:
   14018       return AFL_EXT_XLR;
   14019     }
   14020   return 0;
   14021 }
   14022 
   14023 /* Update the isa_level, isa_rev, isa_ext fields of abiflags.  */
   14024 
   14025 static void
   14026 update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags)
   14027 {
   14028   switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
   14029     {
   14030     case E_MIPS_ARCH_1:
   14031       abiflags->isa_level = 1;
   14032       abiflags->isa_rev = 0;
   14033       break;
   14034     case E_MIPS_ARCH_2:
   14035       abiflags->isa_level = 2;
   14036       abiflags->isa_rev = 0;
   14037       break;
   14038     case E_MIPS_ARCH_3:
   14039       abiflags->isa_level = 3;
   14040       abiflags->isa_rev = 0;
   14041       break;
   14042     case E_MIPS_ARCH_4:
   14043       abiflags->isa_level = 4;
   14044       abiflags->isa_rev = 0;
   14045       break;
   14046     case E_MIPS_ARCH_5:
   14047       abiflags->isa_level = 5;
   14048       abiflags->isa_rev = 0;
   14049       break;
   14050     case E_MIPS_ARCH_32:
   14051       abiflags->isa_level = 32;
   14052       abiflags->isa_rev = 1;
   14053       break;
   14054     case E_MIPS_ARCH_32R2:
   14055       abiflags->isa_level = 32;
   14056       /* Handle MIPS32r3 and MIPS32r5 which do not have a header flag.  */
   14057       if (abiflags->isa_rev < 2)
   14058 	abiflags->isa_rev = 2;
   14059       break;
   14060     case E_MIPS_ARCH_32R6:
   14061       abiflags->isa_level = 32;
   14062       abiflags->isa_rev = 6;
   14063       break;
   14064     case E_MIPS_ARCH_64:
   14065       abiflags->isa_level = 64;
   14066       abiflags->isa_rev = 1;
   14067       break;
   14068     case E_MIPS_ARCH_64R2:
   14069       /* Handle MIPS64r3 and MIPS64r5 which do not have a header flag.  */
   14070       abiflags->isa_level = 64;
   14071       if (abiflags->isa_rev < 2)
   14072 	abiflags->isa_rev = 2;
   14073       break;
   14074     case E_MIPS_ARCH_64R6:
   14075       abiflags->isa_level = 64;
   14076       abiflags->isa_rev = 6;
   14077       break;
   14078     default:
   14079       (*_bfd_error_handler)
   14080 	(_("%B: Unknown architecture %s"),
   14081 	 abfd, bfd_printable_name (abfd));
   14082     }
   14083 
   14084   abiflags->isa_ext = bfd_mips_isa_ext (abfd);
   14085 }
   14086 
   14087 /* Return true if the given ELF header flags describe a 32-bit binary.  */
   14088 
   14089 static bfd_boolean
   14090 mips_32bit_flags_p (flagword flags)
   14091 {
   14092   return ((flags & EF_MIPS_32BITMODE) != 0
   14093 	  || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
   14094 	  || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
   14095 	  || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
   14096 	  || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
   14097 	  || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
   14098 	  || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2
   14099 	  || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6);
   14100 }
   14101 
   14102 /* Infer the content of the ABI flags based on the elf header.  */
   14103 
   14104 static void
   14105 infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags)
   14106 {
   14107   obj_attribute *in_attr;
   14108 
   14109   memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0));
   14110   update_mips_abiflags_isa (abfd, abiflags);
   14111 
   14112   if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags))
   14113     abiflags->gpr_size = AFL_REG_32;
   14114   else
   14115     abiflags->gpr_size = AFL_REG_64;
   14116 
   14117   abiflags->cpr1_size = AFL_REG_NONE;
   14118 
   14119   in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
   14120   abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i;
   14121 
   14122   if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE
   14123       || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX
   14124       || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
   14125 	  && abiflags->gpr_size == AFL_REG_32))
   14126     abiflags->cpr1_size = AFL_REG_32;
   14127   else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
   14128 	   || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64
   14129 	   || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A)
   14130     abiflags->cpr1_size = AFL_REG_64;
   14131 
   14132   abiflags->cpr2_size = AFL_REG_NONE;
   14133 
   14134   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
   14135     abiflags->ases |= AFL_ASE_MDMX;
   14136   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
   14137     abiflags->ases |= AFL_ASE_MIPS16;
   14138   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
   14139     abiflags->ases |= AFL_ASE_MICROMIPS;
   14140 
   14141   if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY
   14142       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT
   14143       && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A
   14144       && abiflags->isa_level >= 32
   14145       && abiflags->isa_ext != AFL_EXT_LOONGSON_3A)
   14146     abiflags->flags1 |= AFL_FLAGS1_ODDSPREG;
   14147 }
   14148 
   14149 /* We need to use a special link routine to handle the .reginfo and
   14150    the .mdebug sections.  We need to merge all instances of these
   14151    sections together, not write them all out sequentially.  */
   14152 
   14153 bfd_boolean
   14154 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   14155 {
   14156   asection *o;
   14157   struct bfd_link_order *p;
   14158   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
   14159   asection *rtproc_sec, *abiflags_sec;
   14160   Elf32_RegInfo reginfo;
   14161   struct ecoff_debug_info debug;
   14162   struct mips_htab_traverse_info hti;
   14163   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   14164   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
   14165   HDRR *symhdr = &debug.symbolic_header;
   14166   void *mdebug_handle = NULL;
   14167   asection *s;
   14168   EXTR esym;
   14169   unsigned int i;
   14170   bfd_size_type amt;
   14171   struct mips_elf_link_hash_table *htab;
   14172 
   14173   static const char * const secname[] =
   14174   {
   14175     ".text", ".init", ".fini", ".data",
   14176     ".rodata", ".sdata", ".sbss", ".bss"
   14177   };
   14178   static const int sc[] =
   14179   {
   14180     scText, scInit, scFini, scData,
   14181     scRData, scSData, scSBss, scBss
   14182   };
   14183 
   14184   /* Sort the dynamic symbols so that those with GOT entries come after
   14185      those without.  */
   14186   htab = mips_elf_hash_table (info);
   14187   BFD_ASSERT (htab != NULL);
   14188 
   14189   if (!mips_elf_sort_hash_table (abfd, info))
   14190     return FALSE;
   14191 
   14192   /* Create any scheduled LA25 stubs.  */
   14193   hti.info = info;
   14194   hti.output_bfd = abfd;
   14195   hti.error = FALSE;
   14196   htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
   14197   if (hti.error)
   14198     return FALSE;
   14199 
   14200   /* Get a value for the GP register.  */
   14201   if (elf_gp (abfd) == 0)
   14202     {
   14203       struct bfd_link_hash_entry *h;
   14204 
   14205       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
   14206       if (h != NULL && h->type == bfd_link_hash_defined)
   14207 	elf_gp (abfd) = (h->u.def.value
   14208 			 + h->u.def.section->output_section->vma
   14209 			 + h->u.def.section->output_offset);
   14210       else if (htab->is_vxworks
   14211 	       && (h = bfd_link_hash_lookup (info->hash,
   14212 					     "_GLOBAL_OFFSET_TABLE_",
   14213 					     FALSE, FALSE, TRUE))
   14214 	       && h->type == bfd_link_hash_defined)
   14215 	elf_gp (abfd) = (h->u.def.section->output_section->vma
   14216 			 + h->u.def.section->output_offset
   14217 			 + h->u.def.value);
   14218       else if (info->relocatable)
   14219 	{
   14220 	  bfd_vma lo = MINUS_ONE;
   14221 
   14222 	  /* Find the GP-relative section with the lowest offset.  */
   14223 	  for (o = abfd->sections; o != NULL; o = o->next)
   14224 	    if (o->vma < lo
   14225 		&& (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
   14226 	      lo = o->vma;
   14227 
   14228 	  /* And calculate GP relative to that.  */
   14229 	  elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
   14230 	}
   14231       else
   14232 	{
   14233 	  /* If the relocate_section function needs to do a reloc
   14234 	     involving the GP value, it should make a reloc_dangerous
   14235 	     callback to warn that GP is not defined.  */
   14236 	}
   14237     }
   14238 
   14239   /* Go through the sections and collect the .reginfo and .mdebug
   14240      information.  */
   14241   abiflags_sec = NULL;
   14242   reginfo_sec = NULL;
   14243   mdebug_sec = NULL;
   14244   gptab_data_sec = NULL;
   14245   gptab_bss_sec = NULL;
   14246   for (o = abfd->sections; o != NULL; o = o->next)
   14247     {
   14248       if (strcmp (o->name, ".MIPS.abiflags") == 0)
   14249 	{
   14250 	  /* We have found the .MIPS.abiflags section in the output file.
   14251 	     Look through all the link_orders comprising it and remove them.
   14252 	     The data is merged in _bfd_mips_elf_merge_private_bfd_data.  */
   14253 	  for (p = o->map_head.link_order; p != NULL; p = p->next)
   14254 	    {
   14255 	      asection *input_section;
   14256 
   14257 	      if (p->type != bfd_indirect_link_order)
   14258 		{
   14259 		  if (p->type == bfd_data_link_order)
   14260 		    continue;
   14261 		  abort ();
   14262 		}
   14263 
   14264 	      input_section = p->u.indirect.section;
   14265 
   14266 	      /* Hack: reset the SEC_HAS_CONTENTS flag so that
   14267 		 elf_link_input_bfd ignores this section.  */
   14268 	      input_section->flags &= ~SEC_HAS_CONTENTS;
   14269 	    }
   14270 
   14271 	  /* Size has been set in _bfd_mips_elf_always_size_sections.  */
   14272 	  BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0));
   14273 
   14274 	  /* Skip this section later on (I don't think this currently
   14275 	     matters, but someday it might).  */
   14276 	  o->map_head.link_order = NULL;
   14277 
   14278 	  abiflags_sec = o;
   14279 	}
   14280 
   14281       if (strcmp (o->name, ".reginfo") == 0)
   14282 	{
   14283 	  memset (&reginfo, 0, sizeof reginfo);
   14284 
   14285 	  /* We have found the .reginfo section in the output file.
   14286 	     Look through all the link_orders comprising it and merge
   14287 	     the information together.  */
   14288 	  for (p = o->map_head.link_order; p != NULL; p = p->next)
   14289 	    {
   14290 	      asection *input_section;
   14291 	      bfd *input_bfd;
   14292 	      Elf32_External_RegInfo ext;
   14293 	      Elf32_RegInfo sub;
   14294 
   14295 	      if (p->type != bfd_indirect_link_order)
   14296 		{
   14297 		  if (p->type == bfd_data_link_order)
   14298 		    continue;
   14299 		  abort ();
   14300 		}
   14301 
   14302 	      input_section = p->u.indirect.section;
   14303 	      input_bfd = input_section->owner;
   14304 
   14305 	      if (! bfd_get_section_contents (input_bfd, input_section,
   14306 					      &ext, 0, sizeof ext))
   14307 		return FALSE;
   14308 
   14309 	      bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
   14310 
   14311 	      reginfo.ri_gprmask |= sub.ri_gprmask;
   14312 	      reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
   14313 	      reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
   14314 	      reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
   14315 	      reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
   14316 
   14317 	      /* ri_gp_value is set by the function
   14318 		 mips_elf32_section_processing when the section is
   14319 		 finally written out.  */
   14320 
   14321 	      /* Hack: reset the SEC_HAS_CONTENTS flag so that
   14322 		 elf_link_input_bfd ignores this section.  */
   14323 	      input_section->flags &= ~SEC_HAS_CONTENTS;
   14324 	    }
   14325 
   14326 	  /* Size has been set in _bfd_mips_elf_always_size_sections.  */
   14327 	  BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
   14328 
   14329 	  /* Skip this section later on (I don't think this currently
   14330 	     matters, but someday it might).  */
   14331 	  o->map_head.link_order = NULL;
   14332 
   14333 	  reginfo_sec = o;
   14334 	}
   14335 
   14336       if (strcmp (o->name, ".mdebug") == 0)
   14337 	{
   14338 	  struct extsym_info einfo;
   14339 	  bfd_vma last;
   14340 
   14341 	  /* We have found the .mdebug section in the output file.
   14342 	     Look through all the link_orders comprising it and merge
   14343 	     the information together.  */
   14344 	  symhdr->magic = swap->sym_magic;
   14345 	  /* FIXME: What should the version stamp be?  */
   14346 	  symhdr->vstamp = 0;
   14347 	  symhdr->ilineMax = 0;
   14348 	  symhdr->cbLine = 0;
   14349 	  symhdr->idnMax = 0;
   14350 	  symhdr->ipdMax = 0;
   14351 	  symhdr->isymMax = 0;
   14352 	  symhdr->ioptMax = 0;
   14353 	  symhdr->iauxMax = 0;
   14354 	  symhdr->issMax = 0;
   14355 	  symhdr->issExtMax = 0;
   14356 	  symhdr->ifdMax = 0;
   14357 	  symhdr->crfd = 0;
   14358 	  symhdr->iextMax = 0;
   14359 
   14360 	  /* We accumulate the debugging information itself in the
   14361 	     debug_info structure.  */
   14362 	  debug.line = NULL;
   14363 	  debug.external_dnr = NULL;
   14364 	  debug.external_pdr = NULL;
   14365 	  debug.external_sym = NULL;
   14366 	  debug.external_opt = NULL;
   14367 	  debug.external_aux = NULL;
   14368 	  debug.ss = NULL;
   14369 	  debug.ssext = debug.ssext_end = NULL;
   14370 	  debug.external_fdr = NULL;
   14371 	  debug.external_rfd = NULL;
   14372 	  debug.external_ext = debug.external_ext_end = NULL;
   14373 
   14374 	  mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
   14375 	  if (mdebug_handle == NULL)
   14376 	    return FALSE;
   14377 
   14378 	  esym.jmptbl = 0;
   14379 	  esym.cobol_main = 0;
   14380 	  esym.weakext = 0;
   14381 	  esym.reserved = 0;
   14382 	  esym.ifd = ifdNil;
   14383 	  esym.asym.iss = issNil;
   14384 	  esym.asym.st = stLocal;
   14385 	  esym.asym.reserved = 0;
   14386 	  esym.asym.index = indexNil;
   14387 	  last = 0;
   14388 	  for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
   14389 	    {
   14390 	      esym.asym.sc = sc[i];
   14391 	      s = bfd_get_section_by_name (abfd, secname[i]);
   14392 	      if (s != NULL)
   14393 		{
   14394 		  esym.asym.value = s->vma;
   14395 		  last = s->vma + s->size;
   14396 		}
   14397 	      else
   14398 		esym.asym.value = last;
   14399 	      if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
   14400 						 secname[i], &esym))
   14401 		return FALSE;
   14402 	    }
   14403 
   14404 	  for (p = o->map_head.link_order; p != NULL; p = p->next)
   14405 	    {
   14406 	      asection *input_section;
   14407 	      bfd *input_bfd;
   14408 	      const struct ecoff_debug_swap *input_swap;
   14409 	      struct ecoff_debug_info input_debug;
   14410 	      char *eraw_src;
   14411 	      char *eraw_end;
   14412 
   14413 	      if (p->type != bfd_indirect_link_order)
   14414 		{
   14415 		  if (p->type == bfd_data_link_order)
   14416 		    continue;
   14417 		  abort ();
   14418 		}
   14419 
   14420 	      input_section = p->u.indirect.section;
   14421 	      input_bfd = input_section->owner;
   14422 
   14423 	      if (!is_mips_elf (input_bfd))
   14424 		{
   14425 		  /* I don't know what a non MIPS ELF bfd would be
   14426 		     doing with a .mdebug section, but I don't really
   14427 		     want to deal with it.  */
   14428 		  continue;
   14429 		}
   14430 
   14431 	      input_swap = (get_elf_backend_data (input_bfd)
   14432 			    ->elf_backend_ecoff_debug_swap);
   14433 
   14434 	      BFD_ASSERT (p->size == input_section->size);
   14435 
   14436 	      /* The ECOFF linking code expects that we have already
   14437 		 read in the debugging information and set up an
   14438 		 ecoff_debug_info structure, so we do that now.  */
   14439 	      if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
   14440 						   &input_debug))
   14441 		return FALSE;
   14442 
   14443 	      if (! (bfd_ecoff_debug_accumulate
   14444 		     (mdebug_handle, abfd, &debug, swap, input_bfd,
   14445 		      &input_debug, input_swap, info)))
   14446 		return FALSE;
   14447 
   14448 	      /* Loop through the external symbols.  For each one with
   14449 		 interesting information, try to find the symbol in
   14450 		 the linker global hash table and save the information
   14451 		 for the output external symbols.  */
   14452 	      eraw_src = input_debug.external_ext;
   14453 	      eraw_end = (eraw_src
   14454 			  + (input_debug.symbolic_header.iextMax
   14455 			     * input_swap->external_ext_size));
   14456 	      for (;
   14457 		   eraw_src < eraw_end;
   14458 		   eraw_src += input_swap->external_ext_size)
   14459 		{
   14460 		  EXTR ext;
   14461 		  const char *name;
   14462 		  struct mips_elf_link_hash_entry *h;
   14463 
   14464 		  (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
   14465 		  if (ext.asym.sc == scNil
   14466 		      || ext.asym.sc == scUndefined
   14467 		      || ext.asym.sc == scSUndefined)
   14468 		    continue;
   14469 
   14470 		  name = input_debug.ssext + ext.asym.iss;
   14471 		  h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
   14472 						 name, FALSE, FALSE, TRUE);
   14473 		  if (h == NULL || h->esym.ifd != -2)
   14474 		    continue;
   14475 
   14476 		  if (ext.ifd != -1)
   14477 		    {
   14478 		      BFD_ASSERT (ext.ifd
   14479 				  < input_debug.symbolic_header.ifdMax);
   14480 		      ext.ifd = input_debug.ifdmap[ext.ifd];
   14481 		    }
   14482 
   14483 		  h->esym = ext;
   14484 		}
   14485 
   14486 	      /* Free up the information we just read.  */
   14487 	      free (input_debug.line);
   14488 	      free (input_debug.external_dnr);
   14489 	      free (input_debug.external_pdr);
   14490 	      free (input_debug.external_sym);
   14491 	      free (input_debug.external_opt);
   14492 	      free (input_debug.external_aux);
   14493 	      free (input_debug.ss);
   14494 	      free (input_debug.ssext);
   14495 	      free (input_debug.external_fdr);
   14496 	      free (input_debug.external_rfd);
   14497 	      free (input_debug.external_ext);
   14498 
   14499 	      /* Hack: reset the SEC_HAS_CONTENTS flag so that
   14500 		 elf_link_input_bfd ignores this section.  */
   14501 	      input_section->flags &= ~SEC_HAS_CONTENTS;
   14502 	    }
   14503 
   14504 	  if (SGI_COMPAT (abfd) && info->shared)
   14505 	    {
   14506 	      /* Create .rtproc section.  */
   14507 	      rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
   14508 	      if (rtproc_sec == NULL)
   14509 		{
   14510 		  flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
   14511 				    | SEC_LINKER_CREATED | SEC_READONLY);
   14512 
   14513 		  rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
   14514 								   ".rtproc",
   14515 								   flags);
   14516 		  if (rtproc_sec == NULL
   14517 		      || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
   14518 		    return FALSE;
   14519 		}
   14520 
   14521 	      if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
   14522 						     info, rtproc_sec,
   14523 						     &debug))
   14524 		return FALSE;
   14525 	    }
   14526 
   14527 	  /* Build the external symbol information.  */
   14528 	  einfo.abfd = abfd;
   14529 	  einfo.info = info;
   14530 	  einfo.debug = &debug;
   14531 	  einfo.swap = swap;
   14532 	  einfo.failed = FALSE;
   14533 	  mips_elf_link_hash_traverse (mips_elf_hash_table (info),
   14534 				       mips_elf_output_extsym, &einfo);
   14535 	  if (einfo.failed)
   14536 	    return FALSE;
   14537 
   14538 	  /* Set the size of the .mdebug section.  */
   14539 	  o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
   14540 
   14541 	  /* Skip this section later on (I don't think this currently
   14542 	     matters, but someday it might).  */
   14543 	  o->map_head.link_order = NULL;
   14544 
   14545 	  mdebug_sec = o;
   14546 	}
   14547 
   14548       if (CONST_STRNEQ (o->name, ".gptab."))
   14549 	{
   14550 	  const char *subname;
   14551 	  unsigned int c;
   14552 	  Elf32_gptab *tab;
   14553 	  Elf32_External_gptab *ext_tab;
   14554 	  unsigned int j;
   14555 
   14556 	  /* The .gptab.sdata and .gptab.sbss sections hold
   14557 	     information describing how the small data area would
   14558 	     change depending upon the -G switch.  These sections
   14559 	     not used in executables files.  */
   14560 	  if (! info->relocatable)
   14561 	    {
   14562 	      for (p = o->map_head.link_order; p != NULL; p = p->next)
   14563 		{
   14564 		  asection *input_section;
   14565 
   14566 		  if (p->type != bfd_indirect_link_order)
   14567 		    {
   14568 		      if (p->type == bfd_data_link_order)
   14569 			continue;
   14570 		      abort ();
   14571 		    }
   14572 
   14573 		  input_section = p->u.indirect.section;
   14574 
   14575 		  /* Hack: reset the SEC_HAS_CONTENTS flag so that
   14576 		     elf_link_input_bfd ignores this section.  */
   14577 		  input_section->flags &= ~SEC_HAS_CONTENTS;
   14578 		}
   14579 
   14580 	      /* Skip this section later on (I don't think this
   14581 		 currently matters, but someday it might).  */
   14582 	      o->map_head.link_order = NULL;
   14583 
   14584 	      /* Really remove the section.  */
   14585 	      bfd_section_list_remove (abfd, o);
   14586 	      --abfd->section_count;
   14587 
   14588 	      continue;
   14589 	    }
   14590 
   14591 	  /* There is one gptab for initialized data, and one for
   14592 	     uninitialized data.  */
   14593 	  if (strcmp (o->name, ".gptab.sdata") == 0)
   14594 	    gptab_data_sec = o;
   14595 	  else if (strcmp (o->name, ".gptab.sbss") == 0)
   14596 	    gptab_bss_sec = o;
   14597 	  else
   14598 	    {
   14599 	      (*_bfd_error_handler)
   14600 		(_("%s: illegal section name `%s'"),
   14601 		 bfd_get_filename (abfd), o->name);
   14602 	      bfd_set_error (bfd_error_nonrepresentable_section);
   14603 	      return FALSE;
   14604 	    }
   14605 
   14606 	  /* The linker script always combines .gptab.data and
   14607 	     .gptab.sdata into .gptab.sdata, and likewise for
   14608 	     .gptab.bss and .gptab.sbss.  It is possible that there is
   14609 	     no .sdata or .sbss section in the output file, in which
   14610 	     case we must change the name of the output section.  */
   14611 	  subname = o->name + sizeof ".gptab" - 1;
   14612 	  if (bfd_get_section_by_name (abfd, subname) == NULL)
   14613 	    {
   14614 	      if (o == gptab_data_sec)
   14615 		o->name = ".gptab.data";
   14616 	      else
   14617 		o->name = ".gptab.bss";
   14618 	      subname = o->name + sizeof ".gptab" - 1;
   14619 	      BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
   14620 	    }
   14621 
   14622 	  /* Set up the first entry.  */
   14623 	  c = 1;
   14624 	  amt = c * sizeof (Elf32_gptab);
   14625 	  tab = bfd_malloc (amt);
   14626 	  if (tab == NULL)
   14627 	    return FALSE;
   14628 	  tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
   14629 	  tab[0].gt_header.gt_unused = 0;
   14630 
   14631 	  /* Combine the input sections.  */
   14632 	  for (p = o->map_head.link_order; p != NULL; p = p->next)
   14633 	    {
   14634 	      asection *input_section;
   14635 	      bfd *input_bfd;
   14636 	      bfd_size_type size;
   14637 	      unsigned long last;
   14638 	      bfd_size_type gpentry;
   14639 
   14640 	      if (p->type != bfd_indirect_link_order)
   14641 		{
   14642 		  if (p->type == bfd_data_link_order)
   14643 		    continue;
   14644 		  abort ();
   14645 		}
   14646 
   14647 	      input_section = p->u.indirect.section;
   14648 	      input_bfd = input_section->owner;
   14649 
   14650 	      /* Combine the gptab entries for this input section one
   14651 		 by one.  We know that the input gptab entries are
   14652 		 sorted by ascending -G value.  */
   14653 	      size = input_section->size;
   14654 	      last = 0;
   14655 	      for (gpentry = sizeof (Elf32_External_gptab);
   14656 		   gpentry < size;
   14657 		   gpentry += sizeof (Elf32_External_gptab))
   14658 		{
   14659 		  Elf32_External_gptab ext_gptab;
   14660 		  Elf32_gptab int_gptab;
   14661 		  unsigned long val;
   14662 		  unsigned long add;
   14663 		  bfd_boolean exact;
   14664 		  unsigned int look;
   14665 
   14666 		  if (! (bfd_get_section_contents
   14667 			 (input_bfd, input_section, &ext_gptab, gpentry,
   14668 			  sizeof (Elf32_External_gptab))))
   14669 		    {
   14670 		      free (tab);
   14671 		      return FALSE;
   14672 		    }
   14673 
   14674 		  bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
   14675 						&int_gptab);
   14676 		  val = int_gptab.gt_entry.gt_g_value;
   14677 		  add = int_gptab.gt_entry.gt_bytes - last;
   14678 
   14679 		  exact = FALSE;
   14680 		  for (look = 1; look < c; look++)
   14681 		    {
   14682 		      if (tab[look].gt_entry.gt_g_value >= val)
   14683 			tab[look].gt_entry.gt_bytes += add;
   14684 
   14685 		      if (tab[look].gt_entry.gt_g_value == val)
   14686 			exact = TRUE;
   14687 		    }
   14688 
   14689 		  if (! exact)
   14690 		    {
   14691 		      Elf32_gptab *new_tab;
   14692 		      unsigned int max;
   14693 
   14694 		      /* We need a new table entry.  */
   14695 		      amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
   14696 		      new_tab = bfd_realloc (tab, amt);
   14697 		      if (new_tab == NULL)
   14698 			{
   14699 			  free (tab);
   14700 			  return FALSE;
   14701 			}
   14702 		      tab = new_tab;
   14703 		      tab[c].gt_entry.gt_g_value = val;
   14704 		      tab[c].gt_entry.gt_bytes = add;
   14705 
   14706 		      /* Merge in the size for the next smallest -G
   14707 			 value, since that will be implied by this new
   14708 			 value.  */
   14709 		      max = 0;
   14710 		      for (look = 1; look < c; look++)
   14711 			{
   14712 			  if (tab[look].gt_entry.gt_g_value < val
   14713 			      && (max == 0
   14714 				  || (tab[look].gt_entry.gt_g_value
   14715 				      > tab[max].gt_entry.gt_g_value)))
   14716 			    max = look;
   14717 			}
   14718 		      if (max != 0)
   14719 			tab[c].gt_entry.gt_bytes +=
   14720 			  tab[max].gt_entry.gt_bytes;
   14721 
   14722 		      ++c;
   14723 		    }
   14724 
   14725 		  last = int_gptab.gt_entry.gt_bytes;
   14726 		}
   14727 
   14728 	      /* Hack: reset the SEC_HAS_CONTENTS flag so that
   14729 		 elf_link_input_bfd ignores this section.  */
   14730 	      input_section->flags &= ~SEC_HAS_CONTENTS;
   14731 	    }
   14732 
   14733 	  /* The table must be sorted by -G value.  */
   14734 	  if (c > 2)
   14735 	    qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
   14736 
   14737 	  /* Swap out the table.  */
   14738 	  amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
   14739 	  ext_tab = bfd_alloc (abfd, amt);
   14740 	  if (ext_tab == NULL)
   14741 	    {
   14742 	      free (tab);
   14743 	      return FALSE;
   14744 	    }
   14745 
   14746 	  for (j = 0; j < c; j++)
   14747 	    bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
   14748 	  free (tab);
   14749 
   14750 	  o->size = c * sizeof (Elf32_External_gptab);
   14751 	  o->contents = (bfd_byte *) ext_tab;
   14752 
   14753 	  /* Skip this section later on (I don't think this currently
   14754 	     matters, but someday it might).  */
   14755 	  o->map_head.link_order = NULL;
   14756 	}
   14757     }
   14758 
   14759   /* Invoke the regular ELF backend linker to do all the work.  */
   14760   if (!bfd_elf_final_link (abfd, info))
   14761     return FALSE;
   14762 
   14763   /* Now write out the computed sections.  */
   14764 
   14765   if (abiflags_sec != NULL)
   14766     {
   14767       Elf_External_ABIFlags_v0 ext;
   14768       Elf_Internal_ABIFlags_v0 *abiflags;
   14769 
   14770       abiflags = &mips_elf_tdata (abfd)->abiflags;
   14771 
   14772       /* Set up the abiflags if no valid input sections were found.  */
   14773       if (!mips_elf_tdata (abfd)->abiflags_valid)
   14774 	{
   14775 	  infer_mips_abiflags (abfd, abiflags);
   14776 	  mips_elf_tdata (abfd)->abiflags_valid = TRUE;
   14777 	}
   14778       bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext);
   14779       if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext))
   14780 	return FALSE;
   14781     }
   14782 
   14783   if (reginfo_sec != NULL)
   14784     {
   14785       Elf32_External_RegInfo ext;
   14786 
   14787       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
   14788       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
   14789 	return FALSE;
   14790     }
   14791 
   14792   if (mdebug_sec != NULL)
   14793     {
   14794       BFD_ASSERT (abfd->output_has_begun);
   14795       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
   14796 					       swap, info,
   14797 					       mdebug_sec->filepos))
   14798 	return FALSE;
   14799 
   14800       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
   14801     }
   14802 
   14803   if (gptab_data_sec != NULL)
   14804     {
   14805       if (! bfd_set_section_contents (abfd, gptab_data_sec,
   14806 				      gptab_data_sec->contents,
   14807 				      0, gptab_data_sec->size))
   14808 	return FALSE;
   14809     }
   14810 
   14811   if (gptab_bss_sec != NULL)
   14812     {
   14813       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
   14814 				      gptab_bss_sec->contents,
   14815 				      0, gptab_bss_sec->size))
   14816 	return FALSE;
   14817     }
   14818 
   14819   if (SGI_COMPAT (abfd))
   14820     {
   14821       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
   14822       if (rtproc_sec != NULL)
   14823 	{
   14824 	  if (! bfd_set_section_contents (abfd, rtproc_sec,
   14825 					  rtproc_sec->contents,
   14826 					  0, rtproc_sec->size))
   14827 	    return FALSE;
   14828 	}
   14829     }
   14830 
   14831   return TRUE;
   14832 }
   14833 
   14834 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
   14836 
   14837 struct mips_mach_extension
   14838 {
   14839   unsigned long extension, base;
   14840 };
   14841 
   14842 
   14843 /* An array describing how BFD machines relate to one another.  The entries
   14844    are ordered topologically with MIPS I extensions listed last.  */
   14845 
   14846 static const struct mips_mach_extension mips_mach_extensions[] =
   14847 {
   14848   /* MIPS64r2 extensions.  */
   14849   { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 },
   14850   { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
   14851   { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
   14852   { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
   14853   { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64r2 },
   14854 
   14855   /* MIPS64 extensions.  */
   14856   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
   14857   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
   14858   { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
   14859 
   14860   /* MIPS V extensions.  */
   14861   { bfd_mach_mipsisa64, bfd_mach_mips5 },
   14862 
   14863   /* R10000 extensions.  */
   14864   { bfd_mach_mips12000, bfd_mach_mips10000 },
   14865   { bfd_mach_mips14000, bfd_mach_mips10000 },
   14866   { bfd_mach_mips16000, bfd_mach_mips10000 },
   14867 
   14868   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
   14869      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
   14870      better to allow vr5400 and vr5500 code to be merged anyway, since
   14871      many libraries will just use the core ISA.  Perhaps we could add
   14872      some sort of ASE flag if this ever proves a problem.  */
   14873   { bfd_mach_mips5500, bfd_mach_mips5400 },
   14874   { bfd_mach_mips5400, bfd_mach_mips5000 },
   14875 
   14876   /* MIPS IV extensions.  */
   14877   { bfd_mach_mips5, bfd_mach_mips8000 },
   14878   { bfd_mach_mips10000, bfd_mach_mips8000 },
   14879   { bfd_mach_mips5000, bfd_mach_mips8000 },
   14880   { bfd_mach_mips7000, bfd_mach_mips8000 },
   14881   { bfd_mach_mips9000, bfd_mach_mips8000 },
   14882 
   14883   /* VR4100 extensions.  */
   14884   { bfd_mach_mips4120, bfd_mach_mips4100 },
   14885   { bfd_mach_mips4111, bfd_mach_mips4100 },
   14886 
   14887   /* MIPS III extensions.  */
   14888   { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
   14889   { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
   14890   { bfd_mach_mips8000, bfd_mach_mips4000 },
   14891   { bfd_mach_mips4650, bfd_mach_mips4000 },
   14892   { bfd_mach_mips4600, bfd_mach_mips4000 },
   14893   { bfd_mach_mips4400, bfd_mach_mips4000 },
   14894   { bfd_mach_mips4300, bfd_mach_mips4000 },
   14895   { bfd_mach_mips4100, bfd_mach_mips4000 },
   14896   { bfd_mach_mips4010, bfd_mach_mips4000 },
   14897   { bfd_mach_mips5900, bfd_mach_mips4000 },
   14898 
   14899   /* MIPS32 extensions.  */
   14900   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
   14901 
   14902   /* MIPS II extensions.  */
   14903   { bfd_mach_mips4000, bfd_mach_mips6000 },
   14904   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
   14905 
   14906   /* MIPS I extensions.  */
   14907   { bfd_mach_mips6000, bfd_mach_mips3000 },
   14908   { bfd_mach_mips3900, bfd_mach_mips3000 }
   14909 };
   14910 
   14911 
   14912 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
   14913 
   14914 static bfd_boolean
   14915 mips_mach_extends_p (unsigned long base, unsigned long extension)
   14916 {
   14917   size_t i;
   14918 
   14919   if (extension == base)
   14920     return TRUE;
   14921 
   14922   if (base == bfd_mach_mipsisa32
   14923       && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
   14924     return TRUE;
   14925 
   14926   if (base == bfd_mach_mipsisa32r2
   14927       && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
   14928     return TRUE;
   14929 
   14930   for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
   14931     if (extension == mips_mach_extensions[i].extension)
   14932       {
   14933 	extension = mips_mach_extensions[i].base;
   14934 	if (extension == base)
   14935 	  return TRUE;
   14936       }
   14937 
   14938   return FALSE;
   14939 }
   14940 
   14941 
   14942 /* Merge object attributes from IBFD into OBFD.  Raise an error if
   14943    there are conflicting attributes.  */
   14944 static bfd_boolean
   14945 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
   14946 {
   14947   obj_attribute *in_attr;
   14948   obj_attribute *out_attr;
   14949   bfd *abi_fp_bfd;
   14950   bfd *abi_msa_bfd;
   14951 
   14952   abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
   14953   in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
   14954   if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY)
   14955     mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
   14956 
   14957   abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd;
   14958   if (!abi_msa_bfd
   14959       && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
   14960     mips_elf_tdata (obfd)->abi_msa_bfd = ibfd;
   14961 
   14962   if (!elf_known_obj_attributes_proc (obfd)[0].i)
   14963     {
   14964       /* This is the first object.  Copy the attributes.  */
   14965       _bfd_elf_copy_obj_attributes (ibfd, obfd);
   14966 
   14967       /* Use the Tag_null value to indicate the attributes have been
   14968 	 initialized.  */
   14969       elf_known_obj_attributes_proc (obfd)[0].i = 1;
   14970 
   14971       return TRUE;
   14972     }
   14973 
   14974   /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
   14975      non-conflicting ones.  */
   14976   out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
   14977   if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
   14978     {
   14979       int out_fp, in_fp;
   14980 
   14981       out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i;
   14982       in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i;
   14983       out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
   14984       if (out_fp == Val_GNU_MIPS_ABI_FP_ANY)
   14985 	out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp;
   14986       else if (out_fp == Val_GNU_MIPS_ABI_FP_XX
   14987 	       && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
   14988 		   || in_fp == Val_GNU_MIPS_ABI_FP_64
   14989 		   || in_fp == Val_GNU_MIPS_ABI_FP_64A))
   14990 	{
   14991 	  mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
   14992 	  out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
   14993 	}
   14994       else if (in_fp == Val_GNU_MIPS_ABI_FP_XX
   14995 	       && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
   14996 		   || out_fp == Val_GNU_MIPS_ABI_FP_64
   14997 		   || out_fp == Val_GNU_MIPS_ABI_FP_64A))
   14998 	/* Keep the current setting.  */;
   14999       else if (out_fp == Val_GNU_MIPS_ABI_FP_64A
   15000 	       && in_fp == Val_GNU_MIPS_ABI_FP_64)
   15001 	{
   15002 	  mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
   15003 	  out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
   15004 	}
   15005       else if (in_fp == Val_GNU_MIPS_ABI_FP_64A
   15006 	       && out_fp == Val_GNU_MIPS_ABI_FP_64)
   15007 	/* Keep the current setting.  */;
   15008       else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY)
   15009 	{
   15010 	  const char *out_string, *in_string;
   15011 
   15012 	  out_string = _bfd_mips_fp_abi_string (out_fp);
   15013 	  in_string = _bfd_mips_fp_abi_string (in_fp);
   15014 	  /* First warn about cases involving unrecognised ABIs.  */
   15015 	  if (!out_string && !in_string)
   15016 	    _bfd_error_handler
   15017 	      (_("Warning: %B uses unknown floating point ABI %d "
   15018 		 "(set by %B), %B uses unknown floating point ABI %d"),
   15019 	       obfd, abi_fp_bfd, ibfd, out_fp, in_fp);
   15020 	  else if (!out_string)
   15021 	    _bfd_error_handler
   15022 	      (_("Warning: %B uses unknown floating point ABI %d "
   15023 		 "(set by %B), %B uses %s"),
   15024 	       obfd, abi_fp_bfd, ibfd, out_fp, in_string);
   15025 	  else if (!in_string)
   15026 	    _bfd_error_handler
   15027 	      (_("Warning: %B uses %s (set by %B), "
   15028 		 "%B uses unknown floating point ABI %d"),
   15029 	       obfd, abi_fp_bfd, ibfd, out_string, in_fp);
   15030 	  else
   15031 	    {
   15032 	      /* If one of the bfds is soft-float, the other must be
   15033 		 hard-float.  The exact choice of hard-float ABI isn't
   15034 		 really relevant to the error message.  */
   15035 	      if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT)
   15036 		out_string = "-mhard-float";
   15037 	      else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT)
   15038 		in_string = "-mhard-float";
   15039 	      _bfd_error_handler
   15040 		(_("Warning: %B uses %s (set by %B), %B uses %s"),
   15041 		 obfd, abi_fp_bfd, ibfd, out_string, in_string);
   15042 	    }
   15043 	}
   15044     }
   15045 
   15046   /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
   15047      non-conflicting ones.  */
   15048   if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i)
   15049     {
   15050       out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1;
   15051       if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY)
   15052 	out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i;
   15053       else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
   15054 	switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i)
   15055 	  {
   15056 	  case Val_GNU_MIPS_ABI_MSA_128:
   15057 	    _bfd_error_handler
   15058 	      (_("Warning: %B uses %s (set by %B), "
   15059 		 "%B uses unknown MSA ABI %d"),
   15060 	       obfd, abi_msa_bfd, ibfd,
   15061 	       "-mmsa", in_attr[Tag_GNU_MIPS_ABI_MSA].i);
   15062 	    break;
   15063 
   15064 	  default:
   15065 	    switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i)
   15066 	      {
   15067 	      case Val_GNU_MIPS_ABI_MSA_128:
   15068 		_bfd_error_handler
   15069 		  (_("Warning: %B uses unknown MSA ABI %d "
   15070 		     "(set by %B), %B uses %s"),
   15071 		     obfd, abi_msa_bfd, ibfd,
   15072 		     out_attr[Tag_GNU_MIPS_ABI_MSA].i, "-mmsa");
   15073 		  break;
   15074 
   15075 	      default:
   15076 		_bfd_error_handler
   15077 		  (_("Warning: %B uses unknown MSA ABI %d "
   15078 		     "(set by %B), %B uses unknown MSA ABI %d"),
   15079 		   obfd, abi_msa_bfd, ibfd,
   15080 		   out_attr[Tag_GNU_MIPS_ABI_MSA].i,
   15081 		   in_attr[Tag_GNU_MIPS_ABI_MSA].i);
   15082 		break;
   15083 	      }
   15084 	  }
   15085     }
   15086 
   15087   /* Merge Tag_compatibility attributes and any common GNU ones.  */
   15088   _bfd_elf_merge_object_attributes (ibfd, obfd);
   15089 
   15090   return TRUE;
   15091 }
   15092 
   15093 /* Merge backend specific data from an object file to the output
   15094    object file when linking.  */
   15095 
   15096 bfd_boolean
   15097 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
   15098 {
   15099   flagword old_flags;
   15100   flagword new_flags;
   15101   bfd_boolean ok;
   15102   bfd_boolean null_input_bfd = TRUE;
   15103   asection *sec;
   15104   obj_attribute *out_attr;
   15105 
   15106   /* Check if we have the same endianness.  */
   15107   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
   15108     {
   15109       (*_bfd_error_handler)
   15110 	(_("%B: endianness incompatible with that of the selected emulation"),
   15111 	 ibfd);
   15112       return FALSE;
   15113     }
   15114 
   15115   if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
   15116     return TRUE;
   15117 
   15118   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
   15119     {
   15120       (*_bfd_error_handler)
   15121 	(_("%B: ABI is incompatible with that of the selected emulation"),
   15122 	 ibfd);
   15123       return FALSE;
   15124     }
   15125 
   15126   /* Set up the FP ABI attribute from the abiflags if it is not already
   15127      set.  */
   15128   if (mips_elf_tdata (ibfd)->abiflags_valid)
   15129     {
   15130       obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
   15131       if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY)
   15132         in_attr[Tag_GNU_MIPS_ABI_FP].i =
   15133 	  mips_elf_tdata (ibfd)->abiflags.fp_abi;
   15134     }
   15135 
   15136   if (!mips_elf_merge_obj_attributes (ibfd, obfd))
   15137     return FALSE;
   15138 
   15139   /* Check to see if the input BFD actually contains any sections.
   15140      If not, its flags may not have been initialised either, but it cannot
   15141      actually cause any incompatibility.  */
   15142   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
   15143     {
   15144       /* Ignore synthetic sections and empty .text, .data and .bss sections
   15145 	 which are automatically generated by gas.  Also ignore fake
   15146 	 (s)common sections, since merely defining a common symbol does
   15147 	 not affect compatibility.  */
   15148       if ((sec->flags & SEC_IS_COMMON) == 0
   15149 	  && strcmp (sec->name, ".reginfo")
   15150 	  && strcmp (sec->name, ".mdebug")
   15151 	  && (sec->size != 0
   15152 	      || (strcmp (sec->name, ".text")
   15153 		  && strcmp (sec->name, ".data")
   15154 		  && strcmp (sec->name, ".bss"))))
   15155 	{
   15156 	  null_input_bfd = FALSE;
   15157 	  break;
   15158 	}
   15159     }
   15160   if (null_input_bfd)
   15161     return TRUE;
   15162 
   15163   /* Populate abiflags using existing information.  */
   15164   if (!mips_elf_tdata (ibfd)->abiflags_valid)
   15165     {
   15166       infer_mips_abiflags (ibfd, &mips_elf_tdata (ibfd)->abiflags);
   15167       mips_elf_tdata (ibfd)->abiflags_valid = TRUE;
   15168     }
   15169   else
   15170     {
   15171       Elf_Internal_ABIFlags_v0 abiflags;
   15172       Elf_Internal_ABIFlags_v0 in_abiflags;
   15173       infer_mips_abiflags (ibfd, &abiflags);
   15174       in_abiflags = mips_elf_tdata (ibfd)->abiflags;
   15175 
   15176       /* It is not possible to infer the correct ISA revision
   15177          for R3 or R5 so drop down to R2 for the checks.  */
   15178       if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5)
   15179 	in_abiflags.isa_rev = 2;
   15180 
   15181       if (in_abiflags.isa_level != abiflags.isa_level
   15182 	  || in_abiflags.isa_rev != abiflags.isa_rev
   15183 	  || in_abiflags.isa_ext != abiflags.isa_ext)
   15184 	(*_bfd_error_handler)
   15185 	  (_("%B: warning: Inconsistent ISA between e_flags and "
   15186 	     ".MIPS.abiflags"), ibfd);
   15187       if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
   15188 	  && in_abiflags.fp_abi != abiflags.fp_abi)
   15189 	(*_bfd_error_handler)
   15190 	  (_("%B: warning: Inconsistent FP ABI between e_flags and "
   15191 	     ".MIPS.abiflags"), ibfd);
   15192       if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
   15193 	(*_bfd_error_handler)
   15194 	  (_("%B: warning: Inconsistent ASEs between e_flags and "
   15195 	     ".MIPS.abiflags"), ibfd);
   15196       if (in_abiflags.isa_ext != abiflags.isa_ext)
   15197 	(*_bfd_error_handler)
   15198 	  (_("%B: warning: Inconsistent ISA extensions between e_flags and "
   15199 	     ".MIPS.abiflags"), ibfd);
   15200       if (in_abiflags.flags2 != 0)
   15201 	(*_bfd_error_handler)
   15202 	  (_("%B: warning: Unexpected flag in the flags2 field of "
   15203 	     ".MIPS.abiflags (0x%lx)"), ibfd,
   15204 	   (unsigned long) in_abiflags.flags2);
   15205     }
   15206 
   15207   if (!mips_elf_tdata (obfd)->abiflags_valid)
   15208     {
   15209       /* Copy input abiflags if output abiflags are not already valid.  */
   15210       mips_elf_tdata (obfd)->abiflags = mips_elf_tdata (ibfd)->abiflags;
   15211       mips_elf_tdata (obfd)->abiflags_valid = TRUE;
   15212     }
   15213 
   15214   if (! elf_flags_init (obfd))
   15215     {
   15216       elf_flags_init (obfd) = TRUE;
   15217       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
   15218       elf_elfheader (obfd)->e_ident[EI_CLASS]
   15219 	= elf_elfheader (ibfd)->e_ident[EI_CLASS];
   15220 
   15221       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
   15222 	  && (bfd_get_arch_info (obfd)->the_default
   15223 	      || mips_mach_extends_p (bfd_get_mach (obfd),
   15224 				      bfd_get_mach (ibfd))))
   15225 	{
   15226 	  if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
   15227 				   bfd_get_mach (ibfd)))
   15228 	    return FALSE;
   15229 
   15230 	  /* Update the ABI flags isa_level, isa_rev and isa_ext fields.  */
   15231 	  update_mips_abiflags_isa (obfd, &mips_elf_tdata (obfd)->abiflags);
   15232 	}
   15233 
   15234       return TRUE;
   15235     }
   15236 
   15237   /* Update the output abiflags fp_abi using the computed fp_abi.  */
   15238   out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
   15239   mips_elf_tdata (obfd)->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i;
   15240 
   15241 #define max(a,b) ((a) > (b) ? (a) : (b))
   15242   /* Merge abiflags.  */
   15243   mips_elf_tdata (obfd)->abiflags.isa_rev
   15244     = max (mips_elf_tdata (obfd)->abiflags.isa_rev,
   15245 	   mips_elf_tdata (ibfd)->abiflags.isa_rev);
   15246   mips_elf_tdata (obfd)->abiflags.gpr_size
   15247     = max (mips_elf_tdata (obfd)->abiflags.gpr_size,
   15248 	   mips_elf_tdata (ibfd)->abiflags.gpr_size);
   15249   mips_elf_tdata (obfd)->abiflags.cpr1_size
   15250     = max (mips_elf_tdata (obfd)->abiflags.cpr1_size,
   15251 	   mips_elf_tdata (ibfd)->abiflags.cpr1_size);
   15252   mips_elf_tdata (obfd)->abiflags.cpr2_size
   15253     = max (mips_elf_tdata (obfd)->abiflags.cpr2_size,
   15254 	   mips_elf_tdata (ibfd)->abiflags.cpr2_size);
   15255 #undef max
   15256   mips_elf_tdata (obfd)->abiflags.ases
   15257     |= mips_elf_tdata (ibfd)->abiflags.ases;
   15258   mips_elf_tdata (obfd)->abiflags.flags1
   15259     |= mips_elf_tdata (ibfd)->abiflags.flags1;
   15260 
   15261   new_flags = elf_elfheader (ibfd)->e_flags;
   15262   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
   15263   old_flags = elf_elfheader (obfd)->e_flags;
   15264 
   15265   /* Check flag compatibility.  */
   15266 
   15267   new_flags &= ~EF_MIPS_NOREORDER;
   15268   old_flags &= ~EF_MIPS_NOREORDER;
   15269 
   15270   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
   15271      doesn't seem to matter.  */
   15272   new_flags &= ~EF_MIPS_XGOT;
   15273   old_flags &= ~EF_MIPS_XGOT;
   15274 
   15275   /* MIPSpro generates ucode info in n64 objects.  Again, we should
   15276      just be able to ignore this.  */
   15277   new_flags &= ~EF_MIPS_UCODE;
   15278   old_flags &= ~EF_MIPS_UCODE;
   15279 
   15280   /* DSOs should only be linked with CPIC code.  */
   15281   if ((ibfd->flags & DYNAMIC) != 0)
   15282     new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
   15283 
   15284   if (new_flags == old_flags)
   15285     return TRUE;
   15286 
   15287   ok = TRUE;
   15288 
   15289   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
   15290       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
   15291     {
   15292       (*_bfd_error_handler)
   15293 	(_("%B: warning: linking abicalls files with non-abicalls files"),
   15294 	 ibfd);
   15295       ok = TRUE;
   15296     }
   15297 
   15298   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
   15299     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
   15300   if (! (new_flags & EF_MIPS_PIC))
   15301     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
   15302 
   15303   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
   15304   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
   15305 
   15306   /* Compare the ISAs.  */
   15307   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
   15308     {
   15309       (*_bfd_error_handler)
   15310 	(_("%B: linking 32-bit code with 64-bit code"),
   15311 	 ibfd);
   15312       ok = FALSE;
   15313     }
   15314   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
   15315     {
   15316       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
   15317       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
   15318 	{
   15319 	  /* Copy the architecture info from IBFD to OBFD.  Also copy
   15320 	     the 32-bit flag (if set) so that we continue to recognise
   15321 	     OBFD as a 32-bit binary.  */
   15322 	  bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
   15323 	  elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
   15324 	  elf_elfheader (obfd)->e_flags
   15325 	    |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
   15326 
   15327 	  /* Update the ABI flags isa_level, isa_rev, isa_ext fields.  */
   15328 	  update_mips_abiflags_isa (obfd, &mips_elf_tdata (obfd)->abiflags);
   15329 
   15330 	  /* Copy across the ABI flags if OBFD doesn't use them
   15331 	     and if that was what caused us to treat IBFD as 32-bit.  */
   15332 	  if ((old_flags & EF_MIPS_ABI) == 0
   15333 	      && mips_32bit_flags_p (new_flags)
   15334 	      && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
   15335 	    elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
   15336 	}
   15337       else
   15338 	{
   15339 	  /* The ISAs aren't compatible.  */
   15340 	  (*_bfd_error_handler)
   15341 	    (_("%B: linking %s module with previous %s modules"),
   15342 	     ibfd,
   15343 	     bfd_printable_name (ibfd),
   15344 	     bfd_printable_name (obfd));
   15345 	  ok = FALSE;
   15346 	}
   15347     }
   15348 
   15349   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
   15350   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
   15351 
   15352   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
   15353      does set EI_CLASS differently from any 32-bit ABI.  */
   15354   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
   15355       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
   15356 	  != elf_elfheader (obfd)->e_ident[EI_CLASS]))
   15357     {
   15358       /* Only error if both are set (to different values).  */
   15359       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
   15360 	  || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
   15361 	      != elf_elfheader (obfd)->e_ident[EI_CLASS]))
   15362 	{
   15363 	  (*_bfd_error_handler)
   15364 	    (_("%B: ABI mismatch: linking %s module with previous %s modules"),
   15365 	     ibfd,
   15366 	     elf_mips_abi_name (ibfd),
   15367 	     elf_mips_abi_name (obfd));
   15368 	  ok = FALSE;
   15369 	}
   15370       new_flags &= ~EF_MIPS_ABI;
   15371       old_flags &= ~EF_MIPS_ABI;
   15372     }
   15373 
   15374   /* Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
   15375      and allow arbitrary mixing of the remaining ASEs (retain the union).  */
   15376   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
   15377     {
   15378       int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
   15379       int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
   15380       int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
   15381       int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
   15382       int micro_mis = old_m16 && new_micro;
   15383       int m16_mis = old_micro && new_m16;
   15384 
   15385       if (m16_mis || micro_mis)
   15386 	{
   15387 	  (*_bfd_error_handler)
   15388 	    (_("%B: ASE mismatch: linking %s module with previous %s modules"),
   15389 	     ibfd,
   15390 	     m16_mis ? "MIPS16" : "microMIPS",
   15391 	     m16_mis ? "microMIPS" : "MIPS16");
   15392 	  ok = FALSE;
   15393 	}
   15394 
   15395       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
   15396 
   15397       new_flags &= ~ EF_MIPS_ARCH_ASE;
   15398       old_flags &= ~ EF_MIPS_ARCH_ASE;
   15399     }
   15400 
   15401   /* Compare NaN encodings.  */
   15402   if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
   15403     {
   15404       _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
   15405 			  ibfd,
   15406 			  (new_flags & EF_MIPS_NAN2008
   15407 			   ? "-mnan=2008" : "-mnan=legacy"),
   15408 			  (old_flags & EF_MIPS_NAN2008
   15409 			   ? "-mnan=2008" : "-mnan=legacy"));
   15410       ok = FALSE;
   15411       new_flags &= ~EF_MIPS_NAN2008;
   15412       old_flags &= ~EF_MIPS_NAN2008;
   15413     }
   15414 
   15415   /* Compare FP64 state.  */
   15416   if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
   15417     {
   15418       _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
   15419 			  ibfd,
   15420 			  (new_flags & EF_MIPS_FP64
   15421 			   ? "-mfp64" : "-mfp32"),
   15422 			  (old_flags & EF_MIPS_FP64
   15423 			   ? "-mfp64" : "-mfp32"));
   15424       ok = FALSE;
   15425       new_flags &= ~EF_MIPS_FP64;
   15426       old_flags &= ~EF_MIPS_FP64;
   15427     }
   15428 
   15429   /* Warn about any other mismatches */
   15430   if (new_flags != old_flags)
   15431     {
   15432       (*_bfd_error_handler)
   15433 	(_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
   15434 	 ibfd, (unsigned long) new_flags,
   15435 	 (unsigned long) old_flags);
   15436       ok = FALSE;
   15437     }
   15438 
   15439   if (! ok)
   15440     {
   15441       bfd_set_error (bfd_error_bad_value);
   15442       return FALSE;
   15443     }
   15444 
   15445   return TRUE;
   15446 }
   15447 
   15448 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
   15449 
   15450 bfd_boolean
   15451 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
   15452 {
   15453   BFD_ASSERT (!elf_flags_init (abfd)
   15454 	      || elf_elfheader (abfd)->e_flags == flags);
   15455 
   15456   elf_elfheader (abfd)->e_flags = flags;
   15457   elf_flags_init (abfd) = TRUE;
   15458   return TRUE;
   15459 }
   15460 
   15461 char *
   15462 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
   15463 {
   15464   switch (dtag)
   15465     {
   15466     default: return "";
   15467     case DT_MIPS_RLD_VERSION:
   15468       return "MIPS_RLD_VERSION";
   15469     case DT_MIPS_TIME_STAMP:
   15470       return "MIPS_TIME_STAMP";
   15471     case DT_MIPS_ICHECKSUM:
   15472       return "MIPS_ICHECKSUM";
   15473     case DT_MIPS_IVERSION:
   15474       return "MIPS_IVERSION";
   15475     case DT_MIPS_FLAGS:
   15476       return "MIPS_FLAGS";
   15477     case DT_MIPS_BASE_ADDRESS:
   15478       return "MIPS_BASE_ADDRESS";
   15479     case DT_MIPS_MSYM:
   15480       return "MIPS_MSYM";
   15481     case DT_MIPS_CONFLICT:
   15482       return "MIPS_CONFLICT";
   15483     case DT_MIPS_LIBLIST:
   15484       return "MIPS_LIBLIST";
   15485     case DT_MIPS_LOCAL_GOTNO:
   15486       return "MIPS_LOCAL_GOTNO";
   15487     case DT_MIPS_CONFLICTNO:
   15488       return "MIPS_CONFLICTNO";
   15489     case DT_MIPS_LIBLISTNO:
   15490       return "MIPS_LIBLISTNO";
   15491     case DT_MIPS_SYMTABNO:
   15492       return "MIPS_SYMTABNO";
   15493     case DT_MIPS_UNREFEXTNO:
   15494       return "MIPS_UNREFEXTNO";
   15495     case DT_MIPS_GOTSYM:
   15496       return "MIPS_GOTSYM";
   15497     case DT_MIPS_HIPAGENO:
   15498       return "MIPS_HIPAGENO";
   15499     case DT_MIPS_RLD_MAP:
   15500       return "MIPS_RLD_MAP";
   15501     case DT_MIPS_RLD_MAP_REL:
   15502       return "MIPS_RLD_MAP_REL";
   15503     case DT_MIPS_DELTA_CLASS:
   15504       return "MIPS_DELTA_CLASS";
   15505     case DT_MIPS_DELTA_CLASS_NO:
   15506       return "MIPS_DELTA_CLASS_NO";
   15507     case DT_MIPS_DELTA_INSTANCE:
   15508       return "MIPS_DELTA_INSTANCE";
   15509     case DT_MIPS_DELTA_INSTANCE_NO:
   15510       return "MIPS_DELTA_INSTANCE_NO";
   15511     case DT_MIPS_DELTA_RELOC:
   15512       return "MIPS_DELTA_RELOC";
   15513     case DT_MIPS_DELTA_RELOC_NO:
   15514       return "MIPS_DELTA_RELOC_NO";
   15515     case DT_MIPS_DELTA_SYM:
   15516       return "MIPS_DELTA_SYM";
   15517     case DT_MIPS_DELTA_SYM_NO:
   15518       return "MIPS_DELTA_SYM_NO";
   15519     case DT_MIPS_DELTA_CLASSSYM:
   15520       return "MIPS_DELTA_CLASSSYM";
   15521     case DT_MIPS_DELTA_CLASSSYM_NO:
   15522       return "MIPS_DELTA_CLASSSYM_NO";
   15523     case DT_MIPS_CXX_FLAGS:
   15524       return "MIPS_CXX_FLAGS";
   15525     case DT_MIPS_PIXIE_INIT:
   15526       return "MIPS_PIXIE_INIT";
   15527     case DT_MIPS_SYMBOL_LIB:
   15528       return "MIPS_SYMBOL_LIB";
   15529     case DT_MIPS_LOCALPAGE_GOTIDX:
   15530       return "MIPS_LOCALPAGE_GOTIDX";
   15531     case DT_MIPS_LOCAL_GOTIDX:
   15532       return "MIPS_LOCAL_GOTIDX";
   15533     case DT_MIPS_HIDDEN_GOTIDX:
   15534       return "MIPS_HIDDEN_GOTIDX";
   15535     case DT_MIPS_PROTECTED_GOTIDX:
   15536       return "MIPS_PROTECTED_GOT_IDX";
   15537     case DT_MIPS_OPTIONS:
   15538       return "MIPS_OPTIONS";
   15539     case DT_MIPS_INTERFACE:
   15540       return "MIPS_INTERFACE";
   15541     case DT_MIPS_DYNSTR_ALIGN:
   15542       return "DT_MIPS_DYNSTR_ALIGN";
   15543     case DT_MIPS_INTERFACE_SIZE:
   15544       return "DT_MIPS_INTERFACE_SIZE";
   15545     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
   15546       return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
   15547     case DT_MIPS_PERF_SUFFIX:
   15548       return "DT_MIPS_PERF_SUFFIX";
   15549     case DT_MIPS_COMPACT_SIZE:
   15550       return "DT_MIPS_COMPACT_SIZE";
   15551     case DT_MIPS_GP_VALUE:
   15552       return "DT_MIPS_GP_VALUE";
   15553     case DT_MIPS_AUX_DYNAMIC:
   15554       return "DT_MIPS_AUX_DYNAMIC";
   15555     case DT_MIPS_PLTGOT:
   15556       return "DT_MIPS_PLTGOT";
   15557     case DT_MIPS_RWPLT:
   15558       return "DT_MIPS_RWPLT";
   15559     }
   15560 }
   15561 
   15562 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
   15563    not known.  */
   15564 
   15565 const char *
   15566 _bfd_mips_fp_abi_string (int fp)
   15567 {
   15568   switch (fp)
   15569     {
   15570       /* These strings aren't translated because they're simply
   15571 	 option lists.  */
   15572     case Val_GNU_MIPS_ABI_FP_DOUBLE:
   15573       return "-mdouble-float";
   15574 
   15575     case Val_GNU_MIPS_ABI_FP_SINGLE:
   15576       return "-msingle-float";
   15577 
   15578     case Val_GNU_MIPS_ABI_FP_SOFT:
   15579       return "-msoft-float";
   15580 
   15581     case Val_GNU_MIPS_ABI_FP_OLD_64:
   15582       return _("-mips32r2 -mfp64 (12 callee-saved)");
   15583 
   15584     case Val_GNU_MIPS_ABI_FP_XX:
   15585       return "-mfpxx";
   15586 
   15587     case Val_GNU_MIPS_ABI_FP_64:
   15588       return "-mgp32 -mfp64";
   15589 
   15590     case Val_GNU_MIPS_ABI_FP_64A:
   15591       return "-mgp32 -mfp64 -mno-odd-spreg";
   15592 
   15593     default:
   15594       return 0;
   15595     }
   15596 }
   15597 
   15598 static void
   15599 print_mips_ases (FILE *file, unsigned int mask)
   15600 {
   15601   if (mask & AFL_ASE_DSP)
   15602     fputs ("\n\tDSP ASE", file);
   15603   if (mask & AFL_ASE_DSPR2)
   15604     fputs ("\n\tDSP R2 ASE", file);
   15605   if (mask & AFL_ASE_DSPR6)
   15606     fputs ("\n\tDSP R6 ASE", file);
   15607   if (mask & AFL_ASE_EVA)
   15608     fputs ("\n\tEnhanced VA Scheme", file);
   15609   if (mask & AFL_ASE_MCU)
   15610     fputs ("\n\tMCU (MicroController) ASE", file);
   15611   if (mask & AFL_ASE_MDMX)
   15612     fputs ("\n\tMDMX ASE", file);
   15613   if (mask & AFL_ASE_MIPS3D)
   15614     fputs ("\n\tMIPS-3D ASE", file);
   15615   if (mask & AFL_ASE_MT)
   15616     fputs ("\n\tMT ASE", file);
   15617   if (mask & AFL_ASE_SMARTMIPS)
   15618     fputs ("\n\tSmartMIPS ASE", file);
   15619   if (mask & AFL_ASE_VIRT)
   15620     fputs ("\n\tVZ ASE", file);
   15621   if (mask & AFL_ASE_MSA)
   15622     fputs ("\n\tMSA ASE", file);
   15623   if (mask & AFL_ASE_MIPS16)
   15624     fputs ("\n\tMIPS16 ASE", file);
   15625   if (mask & AFL_ASE_MICROMIPS)
   15626     fputs ("\n\tMICROMIPS ASE", file);
   15627   if (mask & AFL_ASE_XPA)
   15628     fputs ("\n\tXPA ASE", file);
   15629   if (mask == 0)
   15630     fprintf (file, "\n\t%s", _("None"));
   15631   else if ((mask & ~AFL_ASE_MASK) != 0)
   15632     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
   15633 }
   15634 
   15635 static void
   15636 print_mips_isa_ext (FILE *file, unsigned int isa_ext)
   15637 {
   15638   switch (isa_ext)
   15639     {
   15640     case 0:
   15641       fputs (_("None"), file);
   15642       break;
   15643     case AFL_EXT_XLR:
   15644       fputs ("RMI XLR", file);
   15645       break;
   15646     case AFL_EXT_OCTEON3:
   15647       fputs ("Cavium Networks Octeon3", file);
   15648       break;
   15649     case AFL_EXT_OCTEON2:
   15650       fputs ("Cavium Networks Octeon2", file);
   15651       break;
   15652     case AFL_EXT_OCTEONP:
   15653       fputs ("Cavium Networks OcteonP", file);
   15654       break;
   15655     case AFL_EXT_LOONGSON_3A:
   15656       fputs ("Loongson 3A", file);
   15657       break;
   15658     case AFL_EXT_OCTEON:
   15659       fputs ("Cavium Networks Octeon", file);
   15660       break;
   15661     case AFL_EXT_5900:
   15662       fputs ("Toshiba R5900", file);
   15663       break;
   15664     case AFL_EXT_4650:
   15665       fputs ("MIPS R4650", file);
   15666       break;
   15667     case AFL_EXT_4010:
   15668       fputs ("LSI R4010", file);
   15669       break;
   15670     case AFL_EXT_4100:
   15671       fputs ("NEC VR4100", file);
   15672       break;
   15673     case AFL_EXT_3900:
   15674       fputs ("Toshiba R3900", file);
   15675       break;
   15676     case AFL_EXT_10000:
   15677       fputs ("MIPS R10000", file);
   15678       break;
   15679     case AFL_EXT_SB1:
   15680       fputs ("Broadcom SB-1", file);
   15681       break;
   15682     case AFL_EXT_4111:
   15683       fputs ("NEC VR4111/VR4181", file);
   15684       break;
   15685     case AFL_EXT_4120:
   15686       fputs ("NEC VR4120", file);
   15687       break;
   15688     case AFL_EXT_5400:
   15689       fputs ("NEC VR5400", file);
   15690       break;
   15691     case AFL_EXT_5500:
   15692       fputs ("NEC VR5500", file);
   15693       break;
   15694     case AFL_EXT_LOONGSON_2E:
   15695       fputs ("ST Microelectronics Loongson 2E", file);
   15696       break;
   15697     case AFL_EXT_LOONGSON_2F:
   15698       fputs ("ST Microelectronics Loongson 2F", file);
   15699       break;
   15700     default:
   15701       fprintf (file, "%s (%d)", _("Unknown"), isa_ext);
   15702       break;
   15703     }
   15704 }
   15705 
   15706 static void
   15707 print_mips_fp_abi_value (FILE *file, int val)
   15708 {
   15709   switch (val)
   15710     {
   15711     case Val_GNU_MIPS_ABI_FP_ANY:
   15712       fprintf (file, _("Hard or soft float\n"));
   15713       break;
   15714     case Val_GNU_MIPS_ABI_FP_DOUBLE:
   15715       fprintf (file, _("Hard float (double precision)\n"));
   15716       break;
   15717     case Val_GNU_MIPS_ABI_FP_SINGLE:
   15718       fprintf (file, _("Hard float (single precision)\n"));
   15719       break;
   15720     case Val_GNU_MIPS_ABI_FP_SOFT:
   15721       fprintf (file, _("Soft float\n"));
   15722       break;
   15723     case Val_GNU_MIPS_ABI_FP_OLD_64:
   15724       fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
   15725       break;
   15726     case Val_GNU_MIPS_ABI_FP_XX:
   15727       fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n"));
   15728       break;
   15729     case Val_GNU_MIPS_ABI_FP_64:
   15730       fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
   15731       break;
   15732     case Val_GNU_MIPS_ABI_FP_64A:
   15733       fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
   15734       break;
   15735     default:
   15736       fprintf (file, "??? (%d)\n", val);
   15737       break;
   15738     }
   15739 }
   15740 
   15741 static int
   15742 get_mips_reg_size (int reg_size)
   15743 {
   15744   return (reg_size == AFL_REG_NONE) ? 0
   15745 	 : (reg_size == AFL_REG_32) ? 32
   15746 	 : (reg_size == AFL_REG_64) ? 64
   15747 	 : (reg_size == AFL_REG_128) ? 128
   15748 	 : -1;
   15749 }
   15750 
   15751 bfd_boolean
   15752 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
   15753 {
   15754   FILE *file = ptr;
   15755 
   15756   BFD_ASSERT (abfd != NULL && ptr != NULL);
   15757 
   15758   /* Print normal ELF private data.  */
   15759   _bfd_elf_print_private_bfd_data (abfd, ptr);
   15760 
   15761   /* xgettext:c-format */
   15762   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
   15763 
   15764   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
   15765     fprintf (file, _(" [abi=O32]"));
   15766   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
   15767     fprintf (file, _(" [abi=O64]"));
   15768   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
   15769     fprintf (file, _(" [abi=EABI32]"));
   15770   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
   15771     fprintf (file, _(" [abi=EABI64]"));
   15772   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
   15773     fprintf (file, _(" [abi unknown]"));
   15774   else if (ABI_N32_P (abfd))
   15775     fprintf (file, _(" [abi=N32]"));
   15776   else if (ABI_64_P (abfd))
   15777     fprintf (file, _(" [abi=64]"));
   15778   else
   15779     fprintf (file, _(" [no abi set]"));
   15780 
   15781   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
   15782     fprintf (file, " [mips1]");
   15783   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
   15784     fprintf (file, " [mips2]");
   15785   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
   15786     fprintf (file, " [mips3]");
   15787   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
   15788     fprintf (file, " [mips4]");
   15789   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
   15790     fprintf (file, " [mips5]");
   15791   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
   15792     fprintf (file, " [mips32]");
   15793   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
   15794     fprintf (file, " [mips64]");
   15795   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
   15796     fprintf (file, " [mips32r2]");
   15797   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
   15798     fprintf (file, " [mips64r2]");
   15799   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6)
   15800     fprintf (file, " [mips32r6]");
   15801   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
   15802     fprintf (file, " [mips64r6]");
   15803   else
   15804     fprintf (file, _(" [unknown ISA]"));
   15805 
   15806   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
   15807     fprintf (file, " [mdmx]");
   15808 
   15809   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
   15810     fprintf (file, " [mips16]");
   15811 
   15812   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
   15813     fprintf (file, " [micromips]");
   15814 
   15815   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008)
   15816     fprintf (file, " [nan2008]");
   15817 
   15818   if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64)
   15819     fprintf (file, " [old fp64]");
   15820 
   15821   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
   15822     fprintf (file, " [32bitmode]");
   15823   else
   15824     fprintf (file, _(" [not 32bitmode]"));
   15825 
   15826   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
   15827     fprintf (file, " [noreorder]");
   15828 
   15829   if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
   15830     fprintf (file, " [PIC]");
   15831 
   15832   if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
   15833     fprintf (file, " [CPIC]");
   15834 
   15835   if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
   15836     fprintf (file, " [XGOT]");
   15837 
   15838   if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
   15839     fprintf (file, " [UCODE]");
   15840 
   15841   fputc ('\n', file);
   15842 
   15843   if (mips_elf_tdata (abfd)->abiflags_valid)
   15844     {
   15845       Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags;
   15846       fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version);
   15847       fprintf (file, "\nISA: MIPS%d", abiflags->isa_level);
   15848       if (abiflags->isa_rev > 1)
   15849 	fprintf (file, "r%d", abiflags->isa_rev);
   15850       fprintf (file, "\nGPR size: %d",
   15851 	       get_mips_reg_size (abiflags->gpr_size));
   15852       fprintf (file, "\nCPR1 size: %d",
   15853 	       get_mips_reg_size (abiflags->cpr1_size));
   15854       fprintf (file, "\nCPR2 size: %d",
   15855 	       get_mips_reg_size (abiflags->cpr2_size));
   15856       fputs ("\nFP ABI: ", file);
   15857       print_mips_fp_abi_value (file, abiflags->fp_abi);
   15858       fputs ("ISA Extension: ", file);
   15859       print_mips_isa_ext (file, abiflags->isa_ext);
   15860       fputs ("\nASEs:", file);
   15861       print_mips_ases (file, abiflags->ases);
   15862       fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1);
   15863       fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2);
   15864       fputc ('\n', file);
   15865     }
   15866 
   15867   return TRUE;
   15868 }
   15869 
   15870 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
   15871 {
   15872   { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
   15873   { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
   15874   { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
   15875   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
   15876   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
   15877   { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
   15878   { NULL,                     0,  0, 0,              0 }
   15879 };
   15880 
   15881 /* Merge non visibility st_other attributes.  Ensure that the
   15882    STO_OPTIONAL flag is copied into h->other, even if this is not a
   15883    definiton of the symbol.  */
   15884 void
   15885 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
   15886 				      const Elf_Internal_Sym *isym,
   15887 				      bfd_boolean definition,
   15888 				      bfd_boolean dynamic ATTRIBUTE_UNUSED)
   15889 {
   15890   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
   15891     {
   15892       unsigned char other;
   15893 
   15894       other = (definition ? isym->st_other : h->other);
   15895       other &= ~ELF_ST_VISIBILITY (-1);
   15896       h->other = other | ELF_ST_VISIBILITY (h->other);
   15897     }
   15898 
   15899   if (!definition
   15900       && ELF_MIPS_IS_OPTIONAL (isym->st_other))
   15901     h->other |= STO_OPTIONAL;
   15902 }
   15903 
   15904 /* Decide whether an undefined symbol is special and can be ignored.
   15905    This is the case for OPTIONAL symbols on IRIX.  */
   15906 bfd_boolean
   15907 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
   15908 {
   15909   return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
   15910 }
   15911 
   15912 bfd_boolean
   15913 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
   15914 {
   15915   return (sym->st_shndx == SHN_COMMON
   15916 	  || sym->st_shndx == SHN_MIPS_ACOMMON
   15917 	  || sym->st_shndx == SHN_MIPS_SCOMMON);
   15918 }
   15919 
   15920 /* Return address for Ith PLT stub in section PLT, for relocation REL
   15921    or (bfd_vma) -1 if it should not be included.  */
   15922 
   15923 bfd_vma
   15924 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
   15925 			   const arelent *rel ATTRIBUTE_UNUSED)
   15926 {
   15927   return (plt->vma
   15928 	  + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
   15929 	  + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
   15930 }
   15931 
   15932 /* Build a table of synthetic symbols to represent the PLT.  As with MIPS16
   15933    and microMIPS PLT slots we may have a many-to-one mapping between .plt
   15934    and .got.plt and also the slots may be of a different size each we walk
   15935    the PLT manually fetching instructions and matching them against known
   15936    patterns.  To make things easier standard MIPS slots, if any, always come
   15937    first.  As we don't create proper ELF symbols we use the UDATA.I member
   15938    of ASYMBOL to carry ISA annotation.  The encoding used is the same as
   15939    with the ST_OTHER member of the ELF symbol.  */
   15940 
   15941 long
   15942 _bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
   15943 				    long symcount ATTRIBUTE_UNUSED,
   15944 				    asymbol **syms ATTRIBUTE_UNUSED,
   15945 				    long dynsymcount, asymbol **dynsyms,
   15946 				    asymbol **ret)
   15947 {
   15948   static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_";
   15949   static const char microsuffix[] = "@micromipsplt";
   15950   static const char m16suffix[] = "@mips16plt";
   15951   static const char mipssuffix[] = "@plt";
   15952 
   15953   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
   15954   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   15955   bfd_boolean micromips_p = MICROMIPS_P (abfd);
   15956   Elf_Internal_Shdr *hdr;
   15957   bfd_byte *plt_data;
   15958   bfd_vma plt_offset;
   15959   unsigned int other;
   15960   bfd_vma entry_size;
   15961   bfd_vma plt0_size;
   15962   asection *relplt;
   15963   bfd_vma opcode;
   15964   asection *plt;
   15965   asymbol *send;
   15966   size_t size;
   15967   char *names;
   15968   long counti;
   15969   arelent *p;
   15970   asymbol *s;
   15971   char *nend;
   15972   long count;
   15973   long pi;
   15974   long i;
   15975   long n;
   15976 
   15977   *ret = NULL;
   15978 
   15979   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0)
   15980     return 0;
   15981 
   15982   relplt = bfd_get_section_by_name (abfd, ".rel.plt");
   15983   if (relplt == NULL)
   15984     return 0;
   15985 
   15986   hdr = &elf_section_data (relplt)->this_hdr;
   15987   if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL)
   15988     return 0;
   15989 
   15990   plt = bfd_get_section_by_name (abfd, ".plt");
   15991   if (plt == NULL)
   15992     return 0;
   15993 
   15994   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
   15995   if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
   15996     return -1;
   15997   p = relplt->relocation;
   15998 
   15999   /* Calculating the exact amount of space required for symbols would
   16000      require two passes over the PLT, so just pessimise assuming two
   16001      PLT slots per relocation.  */
   16002   count = relplt->size / hdr->sh_entsize;
   16003   counti = count * bed->s->int_rels_per_ext_rel;
   16004   size = 2 * count * sizeof (asymbol);
   16005   size += count * (sizeof (mipssuffix) +
   16006 		   (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix)));
   16007   for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel)
   16008     size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name);
   16009 
   16010   /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too.  */
   16011   size += sizeof (asymbol) + sizeof (pltname);
   16012 
   16013   if (!bfd_malloc_and_get_section (abfd, plt, &plt_data))
   16014     return -1;
   16015 
   16016   if (plt->size < 16)
   16017     return -1;
   16018 
   16019   s = *ret = bfd_malloc (size);
   16020   if (s == NULL)
   16021     return -1;
   16022   send = s + 2 * count + 1;
   16023 
   16024   names = (char *) send;
   16025   nend = (char *) s + size;
   16026   n = 0;
   16027 
   16028   opcode = bfd_get_micromips_32 (abfd, plt_data + 12);
   16029   if (opcode == 0x3302fffe)
   16030     {
   16031       if (!micromips_p)
   16032 	return -1;
   16033       plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
   16034       other = STO_MICROMIPS;
   16035     }
   16036   else if (opcode == 0x0398c1d0)
   16037     {
   16038       if (!micromips_p)
   16039 	return -1;
   16040       plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
   16041       other = STO_MICROMIPS;
   16042     }
   16043   else
   16044     {
   16045       plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
   16046       other = 0;
   16047     }
   16048 
   16049   s->the_bfd = abfd;
   16050   s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL;
   16051   s->section = plt;
   16052   s->value = 0;
   16053   s->name = names;
   16054   s->udata.i = other;
   16055   memcpy (names, pltname, sizeof (pltname));
   16056   names += sizeof (pltname);
   16057   ++s, ++n;
   16058 
   16059   pi = 0;
   16060   for (plt_offset = plt0_size;
   16061        plt_offset + 8 <= plt->size && s < send;
   16062        plt_offset += entry_size)
   16063     {
   16064       bfd_vma gotplt_addr;
   16065       const char *suffix;
   16066       bfd_vma gotplt_hi;
   16067       bfd_vma gotplt_lo;
   16068       size_t suffixlen;
   16069 
   16070       opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4);
   16071 
   16072       /* Check if the second word matches the expected MIPS16 instruction.  */
   16073       if (opcode == 0x651aeb00)
   16074 	{
   16075 	  if (micromips_p)
   16076 	    return -1;
   16077 	  /* Truncated table???  */
   16078 	  if (plt_offset + 16 > plt->size)
   16079 	    break;
   16080 	  gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12);
   16081 	  entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
   16082 	  suffixlen = sizeof (m16suffix);
   16083 	  suffix = m16suffix;
   16084 	  other = STO_MIPS16;
   16085 	}
   16086       /* Likewise the expected microMIPS instruction (no insn32 mode).  */
   16087       else if (opcode == 0xff220000)
   16088 	{
   16089 	  if (!micromips_p)
   16090 	    return -1;
   16091 	  gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f;
   16092 	  gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
   16093 	  gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18;
   16094 	  gotplt_lo <<= 2;
   16095 	  gotplt_addr = gotplt_hi + gotplt_lo;
   16096 	  gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3;
   16097 	  entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
   16098 	  suffixlen = sizeof (microsuffix);
   16099 	  suffix = microsuffix;
   16100 	  other = STO_MICROMIPS;
   16101 	}
   16102       /* Likewise the expected microMIPS instruction (insn32 mode).  */
   16103       else if ((opcode & 0xffff0000) == 0xff2f0000)
   16104 	{
   16105 	  gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
   16106 	  gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff;
   16107 	  gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
   16108 	  gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
   16109 	  gotplt_addr = gotplt_hi + gotplt_lo;
   16110 	  entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
   16111 	  suffixlen = sizeof (microsuffix);
   16112 	  suffix = microsuffix;
   16113 	  other = STO_MICROMIPS;
   16114 	}
   16115       /* Otherwise assume standard MIPS code.  */
   16116       else
   16117 	{
   16118 	  gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff;
   16119 	  gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff;
   16120 	  gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
   16121 	  gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
   16122 	  gotplt_addr = gotplt_hi + gotplt_lo;
   16123 	  entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
   16124 	  suffixlen = sizeof (mipssuffix);
   16125 	  suffix = mipssuffix;
   16126 	  other = 0;
   16127 	}
   16128       /* Truncated table???  */
   16129       if (plt_offset + entry_size > plt->size)
   16130 	break;
   16131 
   16132       for (i = 0;
   16133 	   i < count && p[pi].address != gotplt_addr;
   16134 	   i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti);
   16135 
   16136       if (i < count)
   16137 	{
   16138 	  size_t namelen;
   16139 	  size_t len;
   16140 
   16141 	  *s = **p[pi].sym_ptr_ptr;
   16142 	  /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
   16143 	     we are defining a symbol, ensure one of them is set.  */
   16144 	  if ((s->flags & BSF_LOCAL) == 0)
   16145 	    s->flags |= BSF_GLOBAL;
   16146 	  s->flags |= BSF_SYNTHETIC;
   16147 	  s->section = plt;
   16148 	  s->value = plt_offset;
   16149 	  s->name = names;
   16150 	  s->udata.i = other;
   16151 
   16152 	  len = strlen ((*p[pi].sym_ptr_ptr)->name);
   16153 	  namelen = len + suffixlen;
   16154 	  if (names + namelen > nend)
   16155 	    break;
   16156 
   16157 	  memcpy (names, (*p[pi].sym_ptr_ptr)->name, len);
   16158 	  names += len;
   16159 	  memcpy (names, suffix, suffixlen);
   16160 	  names += suffixlen;
   16161 
   16162 	  ++s, ++n;
   16163 	  pi = (pi + bed->s->int_rels_per_ext_rel) % counti;
   16164 	}
   16165     }
   16166 
   16167   free (plt_data);
   16168 
   16169   return n;
   16170 }
   16171 
   16172 void
   16173 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
   16174 {
   16175   struct mips_elf_link_hash_table *htab;
   16176   Elf_Internal_Ehdr *i_ehdrp;
   16177 
   16178   i_ehdrp = elf_elfheader (abfd);
   16179   if (link_info)
   16180     {
   16181       htab = mips_elf_hash_table (link_info);
   16182       BFD_ASSERT (htab != NULL);
   16183 
   16184       if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
   16185 	i_ehdrp->e_ident[EI_ABIVERSION] = 1;
   16186     }
   16187 
   16188   _bfd_elf_post_process_headers (abfd, link_info);
   16189 
   16190   if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64
   16191       || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A)
   16192     i_ehdrp->e_ident[EI_ABIVERSION] = 3;
   16193 }
   16194