bfd/elfxx-mips.c

   1 /* MIPS-specific support for ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Most of the information added by Ian Lance Taylor, Cygnus Support,
   7    <ian@cygnus.com>.
   8    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
   9    <mark@codesourcery.com>
  10    Traditional MIPS targets support added by Koundinya.K, Dansk Data
  11    Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
  12
  13    This file is part of BFD, the Binary File Descriptor library.
  14
  15    This program is free software; you can redistribute it and/or modify
  16    it under the terms of the GNU General Public License as published by
  17    the Free Software Foundation; either version 3 of the License, or
  18    (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  28    MA 02110-1301, USA.  */
  29
  30
  31 /* This file handles functionality common to the different MIPS ABI's.  */
  32
  33 #include "sysdep.h"
  34 #include "bfd.h"
  35 #include "libbfd.h"
  36 #include "libiberty.h"
  37 #include "elf-bfd.h"
  38 #include "elfxx-mips.h"
  39 #include "elf/mips.h"
  40 #include "elf-vxworks.h"
  41
  42 /* Get the ECOFF swapping routines.  */
  43 #include "coff/sym.h"
  44 #include "coff/symconst.h"
  45 #include "coff/ecoff.h"
  46 #include "coff/mips.h"
  47
  48 #include "hashtab.h"
  49
  50 /* This structure is used to hold information about one GOT entry.
  51    There are three types of entry:
  52
  53       (1) absolute addresses
  54             (abfd == NULL)
  55       (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
  56             (abfd != NULL, symndx >= 0)
  57       (3) SYMBOL addresses, where SYMBOL is not local to an input bfd
  58             (abfd != NULL, symndx == -1)
  59
  60    Type (3) entries are treated differently for different types of GOT.
  61    In the "master" GOT -- i.e.  the one that describes every GOT
  62    reference needed in the link -- the mips_got_entry is keyed on both
  63    the symbol and the input bfd that references it.  If it turns out
  64    that we need multiple GOTs, we can then use this information to
  65    create separate GOTs for each input bfd.
  66
  67    However, we want each of these separate GOTs to have at most one
  68    entry for a given symbol, so their type (3) entries are keyed only
  69    on the symbol.  The input bfd given by the "abfd" field is somewhat
  70    arbitrary in this case.
  71
  72    This means that when there are multiple GOTs, each GOT has a unique
  73    mips_got_entry for every symbol within it.  We can therefore use the
  74    mips_got_entry fields (tls_type and gotidx) to track the symbol's
  75    GOT index.
  76
  77    However, if it turns out that we need only a single GOT, we continue
  78    to use the master GOT to describe it.  There may therefore be several
  79    mips_got_entries for the same symbol, each with a different input bfd.
  80    We want to make sure that each symbol gets a unique GOT entry, so when
  81    there's a single GOT, we use the symbol's hash entry, not the
  82    mips_got_entry fields, to track a symbol's GOT index.  */
  83 struct mips_got_entry
  84 {
  85   /* The input bfd in which the symbol is defined.  */
  86   bfd *abfd;
  87   /* The index of the symbol, as stored in the relocation r_info, if
  88      we have a local symbol; -1 otherwise.  */
  89   long symndx;
  90   union
  91   {
  92     /* If abfd == NULL, an address that must be stored in the got.  */
  93     bfd_vma address;
  94     /* If abfd != NULL && symndx != -1, the addend of the relocation
  95        that should be added to the symbol value.  */
  96     bfd_vma addend;
  97     /* If abfd != NULL && symndx == -1, the hash table entry
  98        corresponding to symbol in the GOT.  The symbol's entry
  99        is in the local area if h->global_got_area is GGA_NONE,
 100        otherwise it is in the global area.  */
 101     struct mips_elf_link_hash_entry *h;
 102   } d;
 103
 104   /* The TLS types included in this GOT entry (specifically, GD and
 105      IE).  The GD and IE flags can be added as we encounter new
 106      relocations.  LDM can also be set; it will always be alone, not
 107      combined with any GD or IE flags.  An LDM GOT entry will be
 108      a local symbol entry with r_symndx == 0.  */
 109   unsigned char tls_type;
 110
 111   /* The offset from the beginning of the .got section to the entry
 112      corresponding to this symbol+addend.  If it's a global symbol
 113      whose offset is yet to be decided, it's going to be -1.  */
 114   long gotidx;
 115 };
 116
 117 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
 118    The structures form a non-overlapping list that is sorted by increasing
 119    MIN_ADDEND.  */
 120 struct mips_got_page_range
 121 {
 122   struct mips_got_page_range *next;
 123   bfd_signed_vma min_addend;
 124   bfd_signed_vma max_addend;
 125 };
 126
 127 /* This structure describes the range of addends that are applied to page
 128    relocations against a given symbol.  */
 129 struct mips_got_page_entry
 130 {
 131   /* The input bfd in which the symbol is defined.  */
 132   bfd *abfd;
 133   /* The index of the symbol, as stored in the relocation r_info.  */
 134   long symndx;
 135   /* The ranges for this page entry.  */
 136   struct mips_got_page_range *ranges;
 137   /* The maximum number of page entries needed for RANGES.  */
 138   bfd_vma num_pages;
 139 };
 140
 141 /* This structure is used to hold .got information when linking.  */
 142
 143 struct mips_got_info
 144 {
 145   /* The global symbol in the GOT with the lowest index in the dynamic
 146      symbol table.  */
 147   struct elf_link_hash_entry *global_gotsym;
 148   /* The number of global .got entries.  */
 149   unsigned int global_gotno;
 150   /* The number of global .got entries that are in the GGA_RELOC_ONLY area.  */
 151   unsigned int reloc_only_gotno;
 152   /* The number of .got slots used for TLS.  */
 153   unsigned int tls_gotno;
 154   /* The first unused TLS .got entry.  Used only during
 155      mips_elf_initialize_tls_index.  */
 156   unsigned int tls_assigned_gotno;
 157   /* The number of local .got entries, eventually including page entries.  */
 158   unsigned int local_gotno;
 159   /* The maximum number of page entries needed.  */
 160   unsigned int page_gotno;
 161   /* The number of local .got entries we have used.  */
 162   unsigned int assigned_gotno;
 163   /* A hash table holding members of the got.  */
 164   struct htab *got_entries;
 165   /* A hash table of mips_got_page_entry structures.  */
 166   struct htab *got_page_entries;
 167   /* A hash table mapping input bfds to other mips_got_info.  NULL
 168      unless multi-got was necessary.  */
 169   struct htab *bfd2got;
 170   /* In multi-got links, a pointer to the next got (err, rather, most
 171      of the time, it points to the previous got).  */
 172   struct mips_got_info *next;
 173   /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
 174      for none, or MINUS_TWO for not yet assigned.  This is needed
 175      because a single-GOT link may have multiple hash table entries
 176      for the LDM.  It does not get initialized in multi-GOT mode.  */
 177   bfd_vma tls_ldm_offset;
 178 };
 179
 180 /* Map an input bfd to a got in a multi-got link.  */
 181
 182 struct mips_elf_bfd2got_hash
 183 {
 184   bfd *bfd;
 185   struct mips_got_info *g;
 186 };
 187
 188 /* Structure passed when traversing the bfd2got hash table, used to
 189    create and merge bfd's gots.  */
 190
 191 struct mips_elf_got_per_bfd_arg
 192 {
 193   /* A hashtable that maps bfds to gots.  */
 194   htab_t bfd2got;
 195   /* The output bfd.  */
 196   bfd *obfd;
 197   /* The link information.  */
 198   struct bfd_link_info *info;
 199   /* A pointer to the primary got, i.e., the one that's going to get
 200      the implicit relocations from DT_MIPS_LOCAL_GOTNO and
 201      DT_MIPS_GOTSYM.  */
 202   struct mips_got_info *primary;
 203   /* A non-primary got we're trying to merge with other input bfd's
 204      gots.  */
 205   struct mips_got_info *current;
 206   /* The maximum number of got entries that can be addressed with a
 207      16-bit offset.  */
 208   unsigned int max_count;
 209   /* The maximum number of page entries needed by each got.  */
 210   unsigned int max_pages;
 211   /* The total number of global entries which will live in the
 212      primary got and be automatically relocated.  This includes
 213      those not referenced by the primary GOT but included in
 214      the "master" GOT.  */
 215   unsigned int global_count;
 216 };
 217
 218 /* Another structure used to pass arguments for got entries traversal.  */
 219
 220 struct mips_elf_set_global_got_offset_arg
 221 {
 222   struct mips_got_info *g;
 223   int value;
 224   unsigned int needed_relocs;
 225   struct bfd_link_info *info;
 226 };
 227
 228 /* A structure used to count TLS relocations or GOT entries, for GOT
 229    entry or ELF symbol table traversal.  */
 230
 231 struct mips_elf_count_tls_arg
 232 {
 233   struct bfd_link_info *info;
 234   unsigned int needed;
 235 };
 236
 237 struct _mips_elf_section_data
 238 {
 239   struct bfd_elf_section_data elf;
 240   union
 241   {
 242     bfd_byte *tdata;
 243   } u;
 244 };
 245
 246 #define mips_elf_section_data(sec) \
 247   ((struct _mips_elf_section_data *) elf_section_data (sec))
 248
 249 #define is_mips_elf(bfd)                                \
 250   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 251    && elf_tdata (bfd) != NULL                           \
 252    && elf_object_id (bfd) == MIPS_ELF_DATA)
 253
 254 /* The ABI says that every symbol used by dynamic relocations must have
 255    a global GOT entry.  Among other things, this provides the dynamic
 256    linker with a free, directly-indexed cache.  The GOT can therefore
 257    contain symbols that are not referenced by GOT relocations themselves
 258    (in other words, it may have symbols that are not referenced by things
 259    like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
 260
 261    GOT relocations are less likely to overflow if we put the associated
 262    GOT entries towards the beginning.  We therefore divide the global
 263    GOT entries into two areas: "normal" and "reloc-only".  Entries in
 264    the first area can be used for both dynamic relocations and GP-relative
 265    accesses, while those in the "reloc-only" area are for dynamic
 266    relocations only.
 267
 268    These GGA_* ("Global GOT Area") values are organised so that lower
 269    values are more general than higher values.  Also, non-GGA_NONE
 270    values are ordered by the position of the area in the GOT.  */
 271 #define GGA_NORMAL 0
 272 #define GGA_RELOC_ONLY 1
 273 #define GGA_NONE 2
 274
 275 /* Information about a non-PIC interface to a PIC function.  There are
 276    two ways of creating these interfaces.  The first is to add:
 277
 278         lui     $25,%hi(func)
 279         addiu   $25,$25,%lo(func)
 280
 281    immediately before a PIC function "func".  The second is to add:
 282
 283         lui     $25,%hi(func)
 284         j       func
 285         addiu   $25,$25,%lo(func)
 286
 287    to a separate trampoline section.
 288
 289    Stubs of the first kind go in a new section immediately before the
 290    target function.  Stubs of the second kind go in a single section
 291    pointed to by the hash table's "strampoline" field.  */
 292 struct mips_elf_la25_stub {
 293   /* The generated section that contains this stub.  */
 294   asection *stub_section;
 295
 296   /* The offset of the stub from the start of STUB_SECTION.  */
 297   bfd_vma offset;
 298
 299   /* One symbol for the original function.  Its location is available
 300      in H->root.root.u.def.  */
 301   struct mips_elf_link_hash_entry *h;
 302 };
 303
 304 /* Macros for populating a mips_elf_la25_stub.  */
 305
 306 #define LA25_LUI(VAL) (0x3c190000 | (VAL))      /* lui t9,VAL */
 307 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
 308 #define LA25_ADDIU(VAL) (0x27390000 | (VAL))    /* addiu t9,t9,VAL */
 309 #define LA25_LUI_MICROMIPS_1(VAL) (0x41b9)      /* lui t9,VAL */
 310 #define LA25_LUI_MICROMIPS_2(VAL) (VAL)
 311 #define LA25_J_MICROMIPS_1(VAL) (0xd400 | (((VAL) >> 17) & 0x3ff)) /* j VAL */
 312 #define LA25_J_MICROMIPS_2(VAL) ((VAL) >> 1)
 313 #define LA25_ADDIU_MICROMIPS_1(VAL) (0x3339)    /* addiu t9,t9,VAL */
 314 #define LA25_ADDIU_MICROMIPS_2(VAL) (VAL)
 315
 316 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
 317    the dynamic symbols.  */
 318
 319 struct mips_elf_hash_sort_data
 320 {
 321   /* The symbol in the global GOT with the lowest dynamic symbol table
 322      index.  */
 323   struct elf_link_hash_entry *low;
 324   /* The least dynamic symbol table index corresponding to a non-TLS
 325      symbol with a GOT entry.  */
 326   long min_got_dynindx;
 327   /* The greatest dynamic symbol table index corresponding to a symbol
 328      with a GOT entry that is not referenced (e.g., a dynamic symbol
 329      with dynamic relocations pointing to it from non-primary GOTs).  */
 330   long max_unref_got_dynindx;
 331   /* The greatest dynamic symbol table index not corresponding to a
 332      symbol without a GOT entry.  */
 333   long max_non_got_dynindx;
 334 };
 335
 336 /* The MIPS ELF linker needs additional information for each symbol in
 337    the global hash table.  */
 338
 339 struct mips_elf_link_hash_entry
 340 {
 341   struct elf_link_hash_entry root;
 342
 343   /* External symbol information.  */
 344   EXTR esym;
 345
 346   /* The la25 stub we have created for ths symbol, if any.  */
 347   struct mips_elf_la25_stub *la25_stub;
 348
 349   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
 350      this symbol.  */
 351   unsigned int possibly_dynamic_relocs;
 352
 353   /* If there is a stub that 32 bit functions should use to call this
 354      16 bit function, this points to the section containing the stub.  */
 355   asection *fn_stub;
 356
 357   /* If there is a stub that 16 bit functions should use to call this
 358      32 bit function, this points to the section containing the stub.  */
 359   asection *call_stub;
 360
 361   /* This is like the call_stub field, but it is used if the function
 362      being called returns a floating point value.  */
 363   asection *call_fp_stub;
 364
 365 #define GOT_NORMAL      0
 366 #define GOT_TLS_GD      1
 367 #define GOT_TLS_LDM     2
 368 #define GOT_TLS_IE      4
 369 #define GOT_TLS_OFFSET_DONE    0x40
 370 #define GOT_TLS_DONE    0x80
 371   unsigned char tls_type;
 372
 373   /* This is only used in single-GOT mode; in multi-GOT mode there
 374      is one mips_got_entry per GOT entry, so the offset is stored
 375      there.  In single-GOT mode there may be many mips_got_entry
 376      structures all referring to the same GOT slot.  It might be
 377      possible to use root.got.offset instead, but that field is
 378      overloaded already.  */
 379   bfd_vma tls_got_offset;
 380
 381   /* The highest GGA_* value that satisfies all references to this symbol.  */
 382   unsigned int global_got_area : 2;
 383
 384   /* True if all GOT relocations against this symbol are for calls.  This is
 385      a looser condition than no_fn_stub below, because there may be other
 386      non-call non-GOT relocations against the symbol.  */
 387   unsigned int got_only_for_calls : 1;
 388
 389   /* True if one of the relocations described by possibly_dynamic_relocs
 390      is against a readonly section.  */
 391   unsigned int readonly_reloc : 1;
 392
 393   /* True if there is a relocation against this symbol that must be
 394      resolved by the static linker (in other words, if the relocation
 395      cannot possibly be made dynamic).  */
 396   unsigned int has_static_relocs : 1;
 397
 398   /* True if we must not create a .MIPS.stubs entry for this symbol.
 399      This is set, for example, if there are relocations related to
 400      taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
 401      See "MIPS ABI Supplement, 3rd Edition", p. 4-20.  */
 402   unsigned int no_fn_stub : 1;
 403
 404   /* Whether we need the fn_stub; this is true if this symbol appears
 405      in any relocs other than a 16 bit call.  */
 406   unsigned int need_fn_stub : 1;
 407
 408   /* True if this symbol is referenced by branch relocations from
 409      any non-PIC input file.  This is used to determine whether an
 410      la25 stub is required.  */
 411   unsigned int has_nonpic_branches : 1;
 412
 413   /* Does this symbol need a traditional MIPS lazy-binding stub
 414      (as opposed to a PLT entry)?  */
 415   unsigned int needs_lazy_stub : 1;
 416 };
 417
 418 /* MIPS ELF linker hash table.  */
 419
 420 struct mips_elf_link_hash_table
 421 {
 422   struct elf_link_hash_table root;
 423 #if 0
 424   /* We no longer use this.  */
 425   /* String section indices for the dynamic section symbols.  */
 426   bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
 427 #endif
 428
 429   /* The number of .rtproc entries.  */
 430   bfd_size_type procedure_count;
 431
 432   /* The size of the .compact_rel section (if SGI_COMPAT).  */
 433   bfd_size_type compact_rel_size;
 434
 435   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
 436      entry is set to the address of __rld_obj_head as in IRIX5.  */
 437   bfd_boolean use_rld_obj_head;
 438
 439   /* This is the value of the __rld_map or __rld_obj_head symbol.  */
 440   bfd_vma rld_value;
 441
 442   /* This is set if we see any mips16 stub sections.  */
 443   bfd_boolean mips16_stubs_seen;
 444
 445   /* True if we can generate copy relocs and PLTs.  */
 446   bfd_boolean use_plts_and_copy_relocs;
 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 size of the PLT header in bytes.  */
 469   bfd_vma plt_header_size;
 470
 471   /* The size of a PLT entry in bytes.  */
 472   bfd_vma plt_entry_size;
 473
 474   /* The number of functions that need a lazy-binding stub.  */
 475   bfd_vma lazy_stub_count;
 476
 477   /* The size of a function stub entry in bytes.  */
 478   bfd_vma function_stub_size;
 479
 480   /* The number of reserved entries at the beginning of the GOT.  */
 481   unsigned int reserved_gotno;
 482
 483   /* The section used for mips_elf_la25_stub trampolines.
 484      See the comment above that structure for details.  */
 485   asection *strampoline;
 486
 487   /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
 488      pairs.  */
 489   htab_t la25_stubs;
 490
 491   /* A function FN (NAME, IS, OS) that creates a new input section
 492      called NAME and links it to output section OS.  If IS is nonnull,
 493      the new section should go immediately before it, otherwise it
 494      should go at the (current) beginning of OS.
 495
 496      The function returns the new section on success, otherwise it
 497      returns null.  */
 498   asection *(*add_stub_section) (const char *, asection *, asection *);
 499 };
 500
 501 /* Get the MIPS ELF linker hash table from a link_info structure.  */
 502
 503 #define mips_elf_hash_table(p) \
 504   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 505   == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
 506
 507 /* A structure used to communicate with htab_traverse callbacks.  */
 508 struct mips_htab_traverse_info
 509 {
 510   /* The usual link-wide information.  */
 511   struct bfd_link_info *info;
 512   bfd *output_bfd;
 513
 514   /* Starts off FALSE and is set to TRUE if the link should be aborted.  */
 515   bfd_boolean error;
 516 };
 517
 518 #define TLS_RELOC_P(r_type) \
 519   (r_type == R_MIPS_TLS_DTPMOD32                \
 520    || r_type == R_MIPS_TLS_DTPMOD64             \
 521    || r_type == R_MIPS_TLS_DTPREL32             \
 522    || r_type == R_MIPS_TLS_DTPREL64             \
 523    || r_type == R_MIPS_TLS_GD                   \
 524    || r_type == R_MIPS_TLS_LDM                  \
 525    || r_type == R_MIPS_TLS_DTPREL_HI16          \
 526    || r_type == R_MIPS_TLS_DTPREL_LO16          \
 527    || r_type == R_MIPS_TLS_GOTTPREL             \
 528    || r_type == R_MIPS_TLS_TPREL32              \
 529    || r_type == R_MIPS_TLS_TPREL64              \
 530    || r_type == R_MIPS_TLS_TPREL_HI16           \
 531    || r_type == R_MIPS_TLS_TPREL_LO16           \
 532    || r_type == R_MICROMIPS_TLS_GD              \
 533    || r_type == R_MICROMIPS_TLS_LDM             \
 534    || r_type == R_MICROMIPS_TLS_DTPREL_HI16     \
 535    || r_type == R_MICROMIPS_TLS_DTPREL_LO16     \
 536    || r_type == R_MICROMIPS_TLS_GOTTPREL        \
 537    || r_type == R_MICROMIPS_TLS_TPREL_HI16      \
 538    || r_type == R_MICROMIPS_TLS_TPREL_LO16)
 539
 540 /* Structure used to pass information to mips_elf_output_extsym.  */
 541
 542 struct extsym_info
 543 {
 544   bfd *abfd;
 545   struct bfd_link_info *info;
 546   struct ecoff_debug_info *debug;
 547   const struct ecoff_debug_swap *swap;
 548   bfd_boolean failed;
 549 };
 550
 551 /* The names of the runtime procedure table symbols used on IRIX5.  */
 552
 553 static const char * const mips_elf_dynsym_rtproc_names[] =
 554 {
 555   "_procedure_table",
 556   "_procedure_string_table",
 557   "_procedure_table_size",
 558   NULL
 559 };
 560
 561 /* These structures are used to generate the .compact_rel section on
 562    IRIX5.  */
 563
 564 typedef struct
 565 {
 566   unsigned long id1;            /* Always one?  */
 567   unsigned long num;            /* Number of compact relocation entries.  */
 568   unsigned long id2;            /* Always two?  */
 569   unsigned long offset;         /* The file offset of the first relocation.  */
 570   unsigned long reserved0;      /* Zero?  */
 571   unsigned long reserved1;      /* Zero?  */
 572 } Elf32_compact_rel;
 573
 574 typedef struct
 575 {
 576   bfd_byte id1[4];
 577   bfd_byte num[4];
 578   bfd_byte id2[4];
 579   bfd_byte offset[4];
 580   bfd_byte reserved0[4];
 581   bfd_byte reserved1[4];
 582 } Elf32_External_compact_rel;
 583
 584 typedef struct
 585 {
 586   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 587   unsigned int rtype : 4;       /* Relocation types. See below.  */
 588   unsigned int dist2to : 8;
 589   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 590   unsigned long konst;          /* KONST field. See below.  */
 591   unsigned long vaddr;          /* VADDR to be relocated.  */
 592 } Elf32_crinfo;
 593
 594 typedef struct
 595 {
 596   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 597   unsigned int rtype : 4;       /* Relocation types. See below.  */
 598   unsigned int dist2to : 8;
 599   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 600   unsigned long konst;          /* KONST field. See below.  */
 601 } Elf32_crinfo2;
 602
 603 typedef struct
 604 {
 605   bfd_byte info[4];
 606   bfd_byte konst[4];
 607   bfd_byte vaddr[4];
 608 } Elf32_External_crinfo;
 609
 610 typedef struct
 611 {
 612   bfd_byte info[4];
 613   bfd_byte konst[4];
 614 } Elf32_External_crinfo2;
 615
 616 /* These are the constants used to swap the bitfields in a crinfo.  */
 617
 618 #define CRINFO_CTYPE (0x1)
 619 #define CRINFO_CTYPE_SH (31)
 620 #define CRINFO_RTYPE (0xf)
 621 #define CRINFO_RTYPE_SH (27)
 622 #define CRINFO_DIST2TO (0xff)
 623 #define CRINFO_DIST2TO_SH (19)
 624 #define CRINFO_RELVADDR (0x7ffff)
 625 #define CRINFO_RELVADDR_SH (0)
 626
 627 /* A compact relocation info has long (3 words) or short (2 words)
 628    formats.  A short format doesn't have VADDR field and relvaddr
 629    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
 630 #define CRF_MIPS_LONG                   1
 631 #define CRF_MIPS_SHORT                  0
 632
 633 /* There are 4 types of compact relocation at least. The value KONST
 634    has different meaning for each type:
 635
 636    (type)               (konst)
 637    CT_MIPS_REL32        Address in data
 638    CT_MIPS_WORD         Address in word (XXX)
 639    CT_MIPS_GPHI_LO      GP - vaddr
 640    CT_MIPS_JMPAD        Address to jump
 641    */
 642
 643 #define CRT_MIPS_REL32                  0xa
 644 #define CRT_MIPS_WORD                   0xb
 645 #define CRT_MIPS_GPHI_LO                0xc
 646 #define CRT_MIPS_JMPAD                  0xd
 647
 648 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
 649 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
 650 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
 651 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
 652 \f
 653 /* The structure of the runtime procedure descriptor created by the
 654    loader for use by the static exception system.  */
 655
 656 typedef struct runtime_pdr {
 657         bfd_vma adr;            /* Memory address of start of procedure.  */
 658         long    regmask;        /* Save register mask.  */
 659         long    regoffset;      /* Save register offset.  */
 660         long    fregmask;       /* Save floating point register mask.  */
 661         long    fregoffset;     /* Save floating point register offset.  */
 662         long    frameoffset;    /* Frame size.  */
 663         short   framereg;       /* Frame pointer register.  */
 664         short   pcreg;          /* Offset or reg of return pc.  */
 665         long    irpss;          /* Index into the runtime string table.  */
 666         long    reserved;
 667         struct exception_info *exception_info;/* Pointer to exception array.  */
 668 } RPDR, *pRPDR;
 669 #define cbRPDR sizeof (RPDR)
 670 #define rpdNil ((pRPDR) 0)
 671 \f
 672 static struct mips_got_entry *mips_elf_create_local_got_entry
 673   (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
 674    struct mips_elf_link_hash_entry *, int);
 675 static bfd_boolean mips_elf_sort_hash_table_f
 676   (struct mips_elf_link_hash_entry *, void *);
 677 static bfd_vma mips_elf_high
 678   (bfd_vma);
 679 static bfd_boolean mips_elf_create_dynamic_relocation
 680   (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
 681    struct mips_elf_link_hash_entry *, asection *, bfd_vma,
 682    bfd_vma *, asection *);
 683 static hashval_t mips_elf_got_entry_hash
 684   (const void *);
 685 static bfd_vma mips_elf_adjust_gp
 686   (bfd *, struct mips_got_info *, bfd *);
 687 static struct mips_got_info *mips_elf_got_for_ibfd
 688   (struct mips_got_info *, bfd *);
 689
 690 /* This will be used when we sort the dynamic relocation records.  */
 691 static bfd *reldyn_sorting_bfd;
 692
 693 /* True if ABFD is for CPUs with load interlocking that include
 694    non-MIPS1 CPUs and R3900.  */
 695 #define LOAD_INTERLOCKS_P(abfd) \
 696   (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
 697    || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
 698
 699 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
 700    This should be safe for all architectures.  We enable this predicate
 701    for RM9000 for now.  */
 702 #define JAL_TO_BAL_P(abfd) \
 703   ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
 704
 705 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
 706    This should be safe for all architectures.  We enable this predicate for
 707    all CPUs.  */
 708 #define JALR_TO_BAL_P(abfd) 1
 709
 710 /* True if ABFD is for CPUs that are faster if JR is converted to B.
 711    This should be safe for all architectures.  We enable this predicate for
 712    all CPUs.  */
 713 #define JR_TO_B_P(abfd) 1
 714
 715 /* True if ABFD is a PIC object.  */
 716 #define PIC_OBJECT_P(abfd) \
 717   ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
 718
 719 /* Nonzero if ABFD is using the N32 ABI.  */
 720 #define ABI_N32_P(abfd) \
 721   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
 722
 723 /* Nonzero if ABFD is using the N64 ABI.  */
 724 #define ABI_64_P(abfd) \
 725   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
 726
 727 /* Nonzero if ABFD is using NewABI conventions.  */
 728 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
 729
 730 /* The IRIX compatibility level we are striving for.  */
 731 #define IRIX_COMPAT(abfd) \
 732   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
 733
 734 /* Whether we are trying to be compatible with IRIX at all.  */
 735 #define SGI_COMPAT(abfd) \
 736   (IRIX_COMPAT (abfd) != ict_none)
 737
 738 /* The name of the options section.  */
 739 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
 740   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
 741
 742 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
 743    Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
 744 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
 745   (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
 746
 747 /* Whether the section is readonly.  */
 748 #define MIPS_ELF_READONLY_SECTION(sec) \
 749   ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \
 750    == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
 751
 752 /* The name of the stub section.  */
 753 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
 754
 755 /* The size of an external REL relocation.  */
 756 #define MIPS_ELF_REL_SIZE(abfd) \
 757   (get_elf_backend_data (abfd)->s->sizeof_rel)
 758
 759 /* The size of an external RELA relocation.  */
 760 #define MIPS_ELF_RELA_SIZE(abfd) \
 761   (get_elf_backend_data (abfd)->s->sizeof_rela)
 762
 763 /* The size of an external dynamic table entry.  */
 764 #define MIPS_ELF_DYN_SIZE(abfd) \
 765   (get_elf_backend_data (abfd)->s->sizeof_dyn)
 766
 767 /* The size of a GOT entry.  */
 768 #define MIPS_ELF_GOT_SIZE(abfd) \
 769   (get_elf_backend_data (abfd)->s->arch_size / 8)
 770
 771 /* The size of a symbol-table entry.  */
 772 #define MIPS_ELF_SYM_SIZE(abfd) \
 773   (get_elf_backend_data (abfd)->s->sizeof_sym)
 774
 775 /* The default alignment for sections, as a power of two.  */
 776 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
 777   (get_elf_backend_data (abfd)->s->log_file_align)
 778
 779 /* Get word-sized data.  */
 780 #define MIPS_ELF_GET_WORD(abfd, ptr) \
 781   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
 782
 783 /* Put out word-sized data.  */
 784 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
 785   (ABI_64_P (abfd)                              \
 786    ? bfd_put_64 (abfd, val, ptr)                \
 787    : bfd_put_32 (abfd, val, ptr))
 788
 789 /* The opcode for word-sized loads (LW or LD).  */
 790 #define MIPS_ELF_LOAD_WORD(abfd) \
 791   (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
 792
 793 /* Add a dynamic symbol table-entry.  */
 794 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
 795   _bfd_elf_add_dynamic_entry (info, tag, val)
 796
 797 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
 798   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
 799
 800 /* The name of the dynamic relocation section.  */
 801 #define MIPS_ELF_REL_DYN_NAME(INFO) \
 802   (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
 803
 804 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 805    from smaller values.  Start with zero, widen, *then* decrement.  */
 806 #define MINUS_ONE       (((bfd_vma)0) - 1)
 807 #define MINUS_TWO       (((bfd_vma)0) - 2)
 808
 809 /* The value to write into got[1] for SVR4 targets, to identify it is
 810    a GNU object.  The dynamic linker can then use got[1] to store the
 811    module pointer.  */
 812 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
 813   ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
 814
 815 /* The offset of $gp from the beginning of the .got section.  */
 816 #define ELF_MIPS_GP_OFFSET(INFO) \
 817   (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
 818
 819 /* The maximum size of the GOT for it to be addressable using 16-bit
 820    offsets from $gp.  */
 821 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
 822
 823 /* Instructions which appear in a stub.  */
 824 #define STUB_LW(abfd)                                                   \
 825   ((ABI_64_P (abfd)                                                     \
 826     ? 0xdf998010                                /* ld t9,0x8010(gp) */  \
 827     : 0x8f998010))                              /* lw t9,0x8010(gp) */
 828 #define STUB_MOVE(abfd)                                                 \
 829    ((ABI_64_P (abfd)                                                    \
 830      ? 0x03e0782d                               /* daddu t7,ra */       \
 831      : 0x03e07821))                             /* addu t7,ra */
 832 #define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */
 833 #define STUB_JALR 0x0320f809                    /* jalr t9,ra */
 834 #define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */
 835 #define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */
 836 #define STUB_LI16S(abfd, VAL)                                           \
 837    ((ABI_64_P (abfd)                                                    \
 838     ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \
 839     : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */
 840
 841 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
 842 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
 843
 844 /* The name of the dynamic interpreter.  This is put in the .interp
 845    section.  */
 846
 847 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
 848    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
 849     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
 850     : "/usr/lib/libc.so.1")
 851
 852 #ifdef BFD64
 853 #define MNAME(bfd,pre,pos) \
 854   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
 855 #define ELF_R_SYM(bfd, i)                                       \
 856   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
 857 #define ELF_R_TYPE(bfd, i)                                      \
 858   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
 859 #define ELF_R_INFO(bfd, s, t)                                   \
 860   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
 861 #else
 862 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
 863 #define ELF_R_SYM(bfd, i)                                       \
 864   (ELF32_R_SYM (i))
 865 #define ELF_R_TYPE(bfd, i)                                      \
 866   (ELF32_R_TYPE (i))
 867 #define ELF_R_INFO(bfd, s, t)                                   \
 868   (ELF32_R_INFO (s, t))
 869 #endif
 870 \f
 871   /* The mips16 compiler uses a couple of special sections to handle
 872      floating point arguments.
 873
 874      Section names that look like .mips16.fn.FNNAME contain stubs that
 875      copy floating point arguments from the fp regs to the gp regs and
 876      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
 877      call should be redirected to the stub instead.  If no 32 bit
 878      function calls FNNAME, the stub should be discarded.  We need to
 879      consider any reference to the function, not just a call, because
 880      if the address of the function is taken we will need the stub,
 881      since the address might be passed to a 32 bit function.
 882
 883      Section names that look like .mips16.call.FNNAME contain stubs
 884      that copy floating point arguments from the gp regs to the fp
 885      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
 886      then any 16 bit function that calls FNNAME should be redirected
 887      to the stub instead.  If FNNAME is not a 32 bit function, the
 888      stub should be discarded.
 889
 890      .mips16.call.fp.FNNAME sections are similar, but contain stubs
 891      which call FNNAME and then copy the return value from the fp regs
 892      to the gp regs.  These stubs store the return value in $18 while
 893      calling FNNAME; any function which might call one of these stubs
 894      must arrange to save $18 around the call.  (This case is not
 895      needed for 32 bit functions that call 16 bit functions, because
 896      16 bit functions always return floating point values in both
 897      $f0/$f1 and $2/$3.)
 898
 899      Note that in all cases FNNAME might be defined statically.
 900      Therefore, FNNAME is not used literally.  Instead, the relocation
 901      information will indicate which symbol the section is for.
 902
 903      We record any stubs that we find in the symbol table.  */
 904
 905 #define FN_STUB ".mips16.fn."
 906 #define CALL_STUB ".mips16.call."
 907 #define CALL_FP_STUB ".mips16.call.fp."
 908
 909 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
 910 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
 911 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
 912 \f
 913 /* The format of the first PLT entry in an O32 executable.  */
 914 static const bfd_vma mips_o32_exec_plt0_entry[] =
 915 {
 916   0x3c1c0000,   /* lui $28, %hi(&GOTPLT[0])                             */
 917   0x8f990000,   /* lw $25, %lo(&GOTPLT[0])($28)                         */
 918   0x279c0000,   /* addiu $28, $28, %lo(&GOTPLT[0])                      */
 919   0x031cc023,   /* subu $24, $24, $28                                   */
 920   0x03e07821,   /* move $15, $31                                        */
 921   0x0018c082,   /* srl $24, $24, 2                                      */
 922   0x0320f809,   /* jalr $25                                             */
 923   0x2718fffe    /* subu $24, $24, 2                                     */
 924 };
 925
 926 /* The format of the first PLT entry in an N32 executable.  Different
 927    because gp ($28) is not available; we use t2 ($14) instead.  */
 928 static const bfd_vma mips_n32_exec_plt0_entry[] =
 929 {
 930   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
 931   0x8dd90000,   /* lw $25, %lo(&GOTPLT[0])($14)                         */
 932   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
 933   0x030ec023,   /* subu $24, $24, $14                                   */
 934   0x03e07821,   /* move $15, $31                                        */
 935   0x0018c082,   /* srl $24, $24, 2                                      */
 936   0x0320f809,   /* jalr $25                                             */
 937   0x2718fffe    /* subu $24, $24, 2                                     */
 938 };
 939
 940 /* The format of the first PLT entry in an N64 executable.  Different
 941    from N32 because of the increased size of GOT entries.  */
 942 static const bfd_vma mips_n64_exec_plt0_entry[] =
 943 {
 944   0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
 945   0xddd90000,   /* ld $25, %lo(&GOTPLT[0])($14)                         */
 946   0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
 947   0x030ec023,   /* subu $24, $24, $14                                   */
 948   0x03e07821,   /* move $15, $31                                        */
 949   0x0018c0c2,   /* srl $24, $24, 3                                      */
 950   0x0320f809,   /* jalr $25                                             */
 951   0x2718fffe    /* subu $24, $24, 2                                     */
 952 };
 953
 954 /* The format of subsequent PLT entries.  */
 955 static const bfd_vma mips_exec_plt_entry[] =
 956 {
 957   0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
 958   0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
 959   0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
 960   0x03200008    /* jr $25                                       */
 961 };
 962
 963 /* The format of the first PLT entry in a VxWorks executable.  */
 964 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
 965 {
 966   0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */
 967   0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */
 968   0x8f390008,   /* lw t9, 8(t9)                                 */
 969   0x00000000,   /* nop                                          */
 970   0x03200008,   /* jr t9                                        */
 971   0x00000000    /* nop                                          */
 972 };
 973
 974 /* The format of subsequent PLT entries.  */
 975 static const bfd_vma mips_vxworks_exec_plt_entry[] =
 976 {
 977   0x10000000,   /* b .PLT_resolver                      */
 978   0x24180000,   /* li t8, <pltindex>                    */
 979   0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */
 980   0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */
 981   0x8f390000,   /* lw t9, 0(t9)                         */
 982   0x00000000,   /* nop                                  */
 983   0x03200008,   /* jr t9                                */
 984   0x00000000    /* nop                                  */
 985 };
 986
 987 /* The format of the first PLT entry in a VxWorks shared object.  */
 988 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
 989 {
 990   0x8f990008,   /* lw t9, 8(gp)         */
 991   0x00000000,   /* nop                  */
 992   0x03200008,   /* jr t9                */
 993   0x00000000,   /* nop                  */
 994   0x00000000,   /* nop                  */
 995   0x00000000    /* nop                  */
 996 };
 997
 998 /* The format of subsequent PLT entries.  */
 999 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1000 {
1001   0x10000000,   /* b .PLT_resolver      */
1002   0x24180000    /* li t8, <pltindex>    */
1003 };
1004 \f
1005 /* Look up an entry in a MIPS ELF linker hash table.  */
1006
1007 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
1008   ((struct mips_elf_link_hash_entry *)                                  \
1009    elf_link_hash_lookup (&(table)->root, (string), (create),            \
1010                          (copy), (follow)))
1011
1012 /* Traverse a MIPS ELF linker hash table.  */
1013
1014 #define mips_elf_link_hash_traverse(table, func, info)                  \
1015   (elf_link_hash_traverse                                               \
1016    (&(table)->root,                                                     \
1017     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1018     (info)))
1019
1020 /* Find the base offsets for thread-local storage in this object,
1021    for GD/LD and IE/LE respectively.  */
1022
1023 #define TP_OFFSET 0x7000
1024 #define DTP_OFFSET 0x8000
1025
1026 static bfd_vma
1027 dtprel_base (struct bfd_link_info *info)
1028 {
1029   /* If tls_sec is NULL, we should have signalled an error already.  */
1030   if (elf_hash_table (info)->tls_sec == NULL)
1031     return 0;
1032   return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1033 }
1034
1035 static bfd_vma
1036 tprel_base (struct bfd_link_info *info)
1037 {
1038   /* If tls_sec is NULL, we should have signalled an error already.  */
1039   if (elf_hash_table (info)->tls_sec == NULL)
1040     return 0;
1041   return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1042 }
1043
1044 /* Create an entry in a MIPS ELF linker hash table.  */
1045
1046 static struct bfd_hash_entry *
1047 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1048                             struct bfd_hash_table *table, const char *string)
1049 {
1050   struct mips_elf_link_hash_entry *ret =
1051     (struct mips_elf_link_hash_entry *) entry;
1052
1053   /* Allocate the structure if it has not already been allocated by a
1054      subclass.  */
1055   if (ret == NULL)
1056     ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1057   if (ret == NULL)
1058     return (struct bfd_hash_entry *) ret;
1059
1060   /* Call the allocation method of the superclass.  */
1061   ret = ((struct mips_elf_link_hash_entry *)
1062          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1063                                      table, string));
1064   if (ret != NULL)
1065     {
1066       /* Set local fields.  */
1067       memset (&ret->esym, 0, sizeof (EXTR));
1068       /* We use -2 as a marker to indicate that the information has
1069          not been set.  -1 means there is no associated ifd.  */
1070       ret->esym.ifd = -2;
1071       ret->la25_stub = 0;
1072       ret->possibly_dynamic_relocs = 0;
1073       ret->fn_stub = NULL;
1074       ret->call_stub = NULL;
1075       ret->call_fp_stub = NULL;
1076       ret->tls_type = GOT_NORMAL;
1077       ret->global_got_area = GGA_NONE;
1078       ret->got_only_for_calls = TRUE;
1079       ret->readonly_reloc = FALSE;
1080       ret->has_static_relocs = FALSE;
1081       ret->no_fn_stub = FALSE;
1082       ret->need_fn_stub = FALSE;
1083       ret->has_nonpic_branches = FALSE;
1084       ret->needs_lazy_stub = FALSE;
1085     }
1086
1087   return (struct bfd_hash_entry *) ret;
1088 }
1089
1090 bfd_boolean
1091 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1092 {
1093   if (!sec->used_by_bfd)
1094     {
1095       struct _mips_elf_section_data *sdata;
1096       bfd_size_type amt = sizeof (*sdata);
1097
1098       sdata = bfd_zalloc (abfd, amt);
1099       if (sdata == NULL)
1100         return FALSE;
1101       sec->used_by_bfd = sdata;
1102     }
1103
1104   return _bfd_elf_new_section_hook (abfd, sec);
1105 }
1106 \f
1107 /* Read ECOFF debugging information from a .mdebug section into a
1108    ecoff_debug_info structure.  */
1109
1110 bfd_boolean
1111 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1112                                struct ecoff_debug_info *debug)
1113 {
1114   HDRR *symhdr;
1115   const struct ecoff_debug_swap *swap;
1116   char *ext_hdr;
1117
1118   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1119   memset (debug, 0, sizeof (*debug));
1120
1121   ext_hdr = bfd_malloc (swap->external_hdr_size);
1122   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1123     goto error_return;
1124
1125   if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1126                                   swap->external_hdr_size))
1127     goto error_return;
1128
1129   symhdr = &debug->symbolic_header;
1130   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1131
1132   /* The symbolic header contains absolute file offsets and sizes to
1133      read.  */
1134 #define READ(ptr, offset, count, size, type)                            \
1135   if (symhdr->count == 0)                                               \
1136     debug->ptr = NULL;                                                  \
1137   else                                                                  \
1138     {                                                                   \
1139       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1140       debug->ptr = bfd_malloc (amt);                                    \
1141       if (debug->ptr == NULL)                                           \
1142         goto error_return;                                              \
1143       if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0                \
1144           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1145         goto error_return;                                              \
1146     }
1147
1148   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1149   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1150   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1151   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1152   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1153   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1154         union aux_ext *);
1155   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1156   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1157   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1158   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1159   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1160 #undef READ
1161
1162   debug->fdr = NULL;
1163
1164   return TRUE;
1165
1166  error_return:
1167   if (ext_hdr != NULL)
1168     free (ext_hdr);
1169   if (debug->line != NULL)
1170     free (debug->line);
1171   if (debug->external_dnr != NULL)
1172     free (debug->external_dnr);
1173   if (debug->external_pdr != NULL)
1174     free (debug->external_pdr);
1175   if (debug->external_sym != NULL)
1176     free (debug->external_sym);
1177   if (debug->external_opt != NULL)
1178     free (debug->external_opt);
1179   if (debug->external_aux != NULL)
1180     free (debug->external_aux);
1181   if (debug->ss != NULL)
1182     free (debug->ss);
1183   if (debug->ssext != NULL)
1184     free (debug->ssext);
1185   if (debug->external_fdr != NULL)
1186     free (debug->external_fdr);
1187   if (debug->external_rfd != NULL)
1188     free (debug->external_rfd);
1189   if (debug->external_ext != NULL)
1190     free (debug->external_ext);
1191   return FALSE;
1192 }
1193 \f
1194 /* Swap RPDR (runtime procedure table entry) for output.  */
1195
1196 static void
1197 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1198 {
1199   H_PUT_S32 (abfd, in->adr, ex->p_adr);
1200   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1201   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1202   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1203   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1204   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1205
1206   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1207   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1208
1209   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1210 }
1211
1212 /* Create a runtime procedure table from the .mdebug section.  */
1213
1214 static bfd_boolean
1215 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1216                                  struct bfd_link_info *info, asection *s,
1217                                  struct ecoff_debug_info *debug)
1218 {
1219   const struct ecoff_debug_swap *swap;
1220   HDRR *hdr = &debug->symbolic_header;
1221   RPDR *rpdr, *rp;
1222   struct rpdr_ext *erp;
1223   void *rtproc;
1224   struct pdr_ext *epdr;
1225   struct sym_ext *esym;
1226   char *ss, **sv;
1227   char *str;
1228   bfd_size_type size;
1229   bfd_size_type count;
1230   unsigned long sindex;
1231   unsigned long i;
1232   PDR pdr;
1233   SYMR sym;
1234   const char *no_name_func = _("static procedure (no name)");
1235
1236   epdr = NULL;
1237   rpdr = NULL;
1238   esym = NULL;
1239   ss = NULL;
1240   sv = NULL;
1241
1242   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1243
1244   sindex = strlen (no_name_func) + 1;
1245   count = hdr->ipdMax;
1246   if (count > 0)
1247     {
1248       size = swap->external_pdr_size;
1249
1250       epdr = bfd_malloc (size * count);
1251       if (epdr == NULL)
1252         goto error_return;
1253
1254       if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1255         goto error_return;
1256
1257       size = sizeof (RPDR);
1258       rp = rpdr = bfd_malloc (size * count);
1259       if (rpdr == NULL)
1260         goto error_return;
1261
1262       size = sizeof (char *);
1263       sv = bfd_malloc (size * count);
1264       if (sv == NULL)
1265         goto error_return;
1266
1267       count = hdr->isymMax;
1268       size = swap->external_sym_size;
1269       esym = bfd_malloc (size * count);
1270       if (esym == NULL)
1271         goto error_return;
1272
1273       if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1274         goto error_return;
1275
1276       count = hdr->issMax;
1277       ss = bfd_malloc (count);
1278       if (ss == NULL)
1279         goto error_return;
1280       if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1281         goto error_return;
1282
1283       count = hdr->ipdMax;
1284       for (i = 0; i < (unsigned long) count; i++, rp++)
1285         {
1286           (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1287           (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1288           rp->adr = sym.value;
1289           rp->regmask = pdr.regmask;
1290           rp->regoffset = pdr.regoffset;
1291           rp->fregmask = pdr.fregmask;
1292           rp->fregoffset = pdr.fregoffset;
1293           rp->frameoffset = pdr.frameoffset;
1294           rp->framereg = pdr.framereg;
1295           rp->pcreg = pdr.pcreg;
1296           rp->irpss = sindex;
1297           sv[i] = ss + sym.iss;
1298           sindex += strlen (sv[i]) + 1;
1299         }
1300     }
1301
1302   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1303   size = BFD_ALIGN (size, 16);
1304   rtproc = bfd_alloc (abfd, size);
1305   if (rtproc == NULL)
1306     {
1307       mips_elf_hash_table (info)->procedure_count = 0;
1308       goto error_return;
1309     }
1310
1311   mips_elf_hash_table (info)->procedure_count = count + 2;
1312
1313   erp = rtproc;
1314   memset (erp, 0, sizeof (struct rpdr_ext));
1315   erp++;
1316   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1317   strcpy (str, no_name_func);
1318   str += strlen (no_name_func) + 1;
1319   for (i = 0; i < count; i++)
1320     {
1321       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1322       strcpy (str, sv[i]);
1323       str += strlen (sv[i]) + 1;
1324     }
1325   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1326
1327   /* Set the size and contents of .rtproc section.  */
1328   s->size = size;
1329   s->contents = rtproc;
1330
1331   /* Skip this section later on (I don't think this currently
1332      matters, but someday it might).  */
1333   s->map_head.link_order = NULL;
1334
1335   if (epdr != NULL)
1336     free (epdr);
1337   if (rpdr != NULL)
1338     free (rpdr);
1339   if (esym != NULL)
1340     free (esym);
1341   if (ss != NULL)
1342     free (ss);
1343   if (sv != NULL)
1344     free (sv);
1345
1346   return TRUE;
1347
1348  error_return:
1349   if (epdr != NULL)
1350     free (epdr);
1351   if (rpdr != NULL)
1352     free (rpdr);
1353   if (esym != NULL)
1354     free (esym);
1355   if (ss != NULL)
1356     free (ss);
1357   if (sv != NULL)
1358     free (sv);
1359   return FALSE;
1360 }
1361 \f
1362 /* We're going to create a stub for H.  Create a symbol for the stub's
1363    value and size, to help make the disassembly easier to read.  */
1364
1365 static bfd_boolean
1366 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1367                              struct mips_elf_link_hash_entry *h,
1368                              const char *prefix, asection *s, bfd_vma value,
1369                              bfd_vma size)
1370 {
1371   struct bfd_link_hash_entry *bh;
1372   struct elf_link_hash_entry *elfh;
1373   const char *name;
1374
1375   if (ELF_ST_IS_MICROMIPS (h->root.other))
1376     value |= 1;
1377
1378   /* Create a new symbol.  */
1379   name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1380   bh = NULL;
1381   if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1382                                          BSF_LOCAL, s, value, NULL,
1383                                          TRUE, FALSE, &bh))
1384     return FALSE;
1385
1386   /* Make it a local function.  */
1387   elfh = (struct elf_link_hash_entry *) bh;
1388   elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1389   elfh->size = size;
1390   elfh->forced_local = 1;
1391   return TRUE;
1392 }
1393
1394 /* We're about to redefine H.  Create a symbol to represent H's
1395    current value and size, to help make the disassembly easier
1396    to read.  */
1397
1398 static bfd_boolean
1399 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1400                                struct mips_elf_link_hash_entry *h,
1401                                const char *prefix)
1402 {
1403   struct bfd_link_hash_entry *bh;
1404   struct elf_link_hash_entry *elfh;
1405   const char *name;
1406   asection *s;
1407   bfd_vma value;
1408
1409   /* Read the symbol's value.  */
1410   BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1411               || h->root.root.type == bfd_link_hash_defweak);
1412   s = h->root.root.u.def.section;
1413   value = h->root.root.u.def.value;
1414
1415   /* Create a new symbol.  */
1416   name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1417   bh = NULL;
1418   if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1419                                          BSF_LOCAL, s, value, NULL,
1420                                          TRUE, FALSE, &bh))
1421     return FALSE;
1422
1423   /* Make it local and copy the other attributes from H.  */
1424   elfh = (struct elf_link_hash_entry *) bh;
1425   elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1426   elfh->other = h->root.other;
1427   elfh->size = h->root.size;
1428   elfh->forced_local = 1;
1429   return TRUE;
1430 }
1431
1432 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1433    function rather than to a hard-float stub.  */
1434
1435 static bfd_boolean
1436 section_allows_mips16_refs_p (asection *section)
1437 {
1438   const char *name;
1439
1440   name = bfd_get_section_name (section->owner, section);
1441   return (FN_STUB_P (name)
1442           || CALL_STUB_P (name)
1443           || CALL_FP_STUB_P (name)
1444           || strcmp (name, ".pdr") == 0);
1445 }
1446
1447 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1448    stub section of some kind.  Return the R_SYMNDX of the target
1449    function, or 0 if we can't decide which function that is.  */
1450
1451 static unsigned long
1452 mips16_stub_symndx (asection *sec ATTRIBUTE_UNUSED,
1453                     const Elf_Internal_Rela *relocs,
1454                     const Elf_Internal_Rela *relend)
1455 {
1456   const Elf_Internal_Rela *rel;
1457
1458   /* Trust the first R_MIPS_NONE relocation, if any.  */
1459   for (rel = relocs; rel < relend; rel++)
1460     if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1461       return ELF_R_SYM (sec->owner, rel->r_info);
1462
1463   /* Otherwise trust the first relocation, whatever its kind.  This is
1464      the traditional behavior.  */
1465   if (relocs < relend)
1466     return ELF_R_SYM (sec->owner, relocs->r_info);
1467
1468   return 0;
1469 }
1470
1471 /* Check the mips16 stubs for a particular symbol, and see if we can
1472    discard them.  */
1473
1474 static void
1475 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1476                              struct mips_elf_link_hash_entry *h)
1477 {
1478   /* Dynamic symbols must use the standard call interface, in case other
1479      objects try to call them.  */
1480   if (h->fn_stub != NULL
1481       && h->root.dynindx != -1)
1482     {
1483       mips_elf_create_shadow_symbol (info, h, ".mips16.");
1484       h->need_fn_stub = TRUE;
1485     }
1486
1487   if (h->fn_stub != NULL
1488       && ! h->need_fn_stub)
1489     {
1490       /* We don't need the fn_stub; the only references to this symbol
1491          are 16 bit calls.  Clobber the size to 0 to prevent it from
1492          being included in the link.  */
1493       h->fn_stub->size = 0;
1494       h->fn_stub->flags &= ~SEC_RELOC;
1495       h->fn_stub->reloc_count = 0;
1496       h->fn_stub->flags |= SEC_EXCLUDE;
1497     }
1498
1499   if (h->call_stub != NULL
1500       && ELF_ST_IS_MIPS16 (h->root.other))
1501     {
1502       /* We don't need the call_stub; this is a 16 bit function, so
1503          calls from other 16 bit functions are OK.  Clobber the size
1504          to 0 to prevent it from being included in the link.  */
1505       h->call_stub->size = 0;
1506       h->call_stub->flags &= ~SEC_RELOC;
1507       h->call_stub->reloc_count = 0;
1508       h->call_stub->flags |= SEC_EXCLUDE;
1509     }
1510
1511   if (h->call_fp_stub != NULL
1512       && ELF_ST_IS_MIPS16 (h->root.other))
1513     {
1514       /* We don't need the call_stub; this is a 16 bit function, so
1515          calls from other 16 bit functions are OK.  Clobber the size
1516          to 0 to prevent it from being included in the link.  */
1517       h->call_fp_stub->size = 0;
1518       h->call_fp_stub->flags &= ~SEC_RELOC;
1519       h->call_fp_stub->reloc_count = 0;
1520       h->call_fp_stub->flags |= SEC_EXCLUDE;
1521     }
1522 }
1523
1524 /* Hashtable callbacks for mips_elf_la25_stubs.  */
1525
1526 static hashval_t
1527 mips_elf_la25_stub_hash (const void *entry_)
1528 {
1529   const struct mips_elf_la25_stub *entry;
1530
1531   entry = (struct mips_elf_la25_stub *) entry_;
1532   return entry->h->root.root.u.def.section->id
1533     + entry->h->root.root.u.def.value;
1534 }
1535
1536 static int
1537 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1538 {
1539   const struct mips_elf_la25_stub *entry1, *entry2;
1540
1541   entry1 = (struct mips_elf_la25_stub *) entry1_;
1542   entry2 = (struct mips_elf_la25_stub *) entry2_;
1543   return ((entry1->h->root.root.u.def.section
1544            == entry2->h->root.root.u.def.section)
1545           && (entry1->h->root.root.u.def.value
1546               == entry2->h->root.root.u.def.value));
1547 }
1548
1549 /* Called by the linker to set up the la25 stub-creation code.  FN is
1550    the linker's implementation of add_stub_function.  Return true on
1551    success.  */
1552
1553 bfd_boolean
1554 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1555                           asection *(*fn) (const char *, asection *,
1556                                            asection *))
1557 {
1558   struct mips_elf_link_hash_table *htab;
1559
1560   htab = mips_elf_hash_table (info);
1561   if (htab == NULL)
1562     return FALSE;
1563
1564   htab->add_stub_section = fn;
1565   htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1566                                       mips_elf_la25_stub_eq, NULL);
1567   if (htab->la25_stubs == NULL)
1568     return FALSE;
1569
1570   return TRUE;
1571 }
1572
1573 /* Return true if H is a locally-defined PIC function, in the sense
1574    that it might need $25 to be valid on entry.  Note that MIPS16
1575    functions never need $25 to be valid on entry; they set up $gp
1576    using PC-relative instructions instead.  */
1577
1578 static bfd_boolean
1579 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1580 {
1581   return ((h->root.root.type == bfd_link_hash_defined
1582            || h->root.root.type == bfd_link_hash_defweak)
1583           && h->root.def_regular
1584           && !bfd_is_abs_section (h->root.root.u.def.section)
1585           && !ELF_ST_IS_MIPS16 (h->root.other)
1586           && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1587               || ELF_ST_IS_MIPS_PIC (h->root.other)));
1588 }
1589
1590 /* STUB describes an la25 stub that we have decided to implement
1591    by inserting an LUI/ADDIU pair before the target function.
1592    Create the section and redirect the function symbol to it.  */
1593
1594 static bfd_boolean
1595 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1596                          struct bfd_link_info *info)
1597 {
1598   struct mips_elf_link_hash_table *htab;
1599   char *name;
1600   asection *s, *input_section;
1601   unsigned int align;
1602
1603   htab = mips_elf_hash_table (info);
1604   if (htab == NULL)
1605     return FALSE;
1606
1607   /* Create a unique name for the new section.  */
1608   name = bfd_malloc (11 + sizeof (".text.stub."));
1609   if (name == NULL)
1610     return FALSE;
1611   sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1612
1613   /* Create the section.  */
1614   input_section = stub->h->root.root.u.def.section;
1615   s = htab->add_stub_section (name, input_section,
1616                               input_section->output_section);
1617   if (s == NULL)
1618     return FALSE;
1619
1620   /* Make sure that any padding goes before the stub.  */
1621   align = input_section->alignment_power;
1622   if (!bfd_set_section_alignment (s->owner, s, align))
1623     return FALSE;
1624   if (align > 3)
1625     s->size = (1 << align) - 8;
1626
1627   /* Create a symbol for the stub.  */
1628   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1629   stub->stub_section = s;
1630   stub->offset = s->size;
1631
1632   /* Allocate room for it.  */
1633   s->size += 8;
1634   return TRUE;
1635 }
1636
1637 /* STUB describes an la25 stub that we have decided to implement
1638    with a separate trampoline.  Allocate room for it and redirect
1639    the function symbol to it.  */
1640
1641 static bfd_boolean
1642 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1643                               struct bfd_link_info *info)
1644 {
1645   struct mips_elf_link_hash_table *htab;
1646   asection *s;
1647
1648   htab = mips_elf_hash_table (info);
1649   if (htab == NULL)
1650     return FALSE;
1651
1652   /* Create a trampoline section, if we haven't already.  */
1653   s = htab->strampoline;
1654   if (s == NULL)
1655     {
1656       asection *input_section = stub->h->root.root.u.def.section;
1657       s = htab->add_stub_section (".text", NULL,
1658                                   input_section->output_section);
1659       if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1660         return FALSE;
1661       htab->strampoline = s;
1662     }
1663
1664   /* Create a symbol for the stub.  */
1665   mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1666   stub->stub_section = s;
1667   stub->offset = s->size;
1668
1669   /* Allocate room for it.  */
1670   s->size += 16;
1671   return TRUE;
1672 }
1673
1674 /* H describes a symbol that needs an la25 stub.  Make sure that an
1675    appropriate stub exists and point H at it.  */
1676
1677 static bfd_boolean
1678 mips_elf_add_la25_stub (struct bfd_link_info *info,
1679                         struct mips_elf_link_hash_entry *h)
1680 {
1681   struct mips_elf_link_hash_table *htab;
1682   struct mips_elf_la25_stub search, *stub;
1683   bfd_boolean use_trampoline_p;
1684   asection *s;
1685   bfd_vma value;
1686   void **slot;
1687
1688   /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1689      of the section and if we would need no more than 2 nops.  */
1690   s = h->root.root.u.def.section;
1691   value = h->root.root.u.def.value;
1692   use_trampoline_p = (value != 0 || s->alignment_power > 4);
1693
1694   /* Describe the stub we want.  */
1695   search.stub_section = NULL;
1696   search.offset = 0;
1697   search.h = h;
1698
1699   /* See if we've already created an equivalent stub.  */
1700   htab = mips_elf_hash_table (info);
1701   if (htab == NULL)
1702     return FALSE;
1703
1704   slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1705   if (slot == NULL)
1706     return FALSE;
1707
1708   stub = (struct mips_elf_la25_stub *) *slot;
1709   if (stub != NULL)
1710     {
1711       /* We can reuse the existing stub.  */
1712       h->la25_stub = stub;
1713       return TRUE;
1714     }
1715
1716   /* Create a permanent copy of ENTRY and add it to the hash table.  */
1717   stub = bfd_malloc (sizeof (search));
1718   if (stub == NULL)
1719     return FALSE;
1720   *stub = search;
1721   *slot = stub;
1722
1723   h->la25_stub = stub;
1724   return (use_trampoline_p
1725           ? mips_elf_add_la25_trampoline (stub, info)
1726           : mips_elf_add_la25_intro (stub, info));
1727 }
1728
1729 /* A mips_elf_link_hash_traverse callback that is called before sizing
1730    sections.  DATA points to a mips_htab_traverse_info structure.  */
1731
1732 static bfd_boolean
1733 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1734 {
1735   struct mips_htab_traverse_info *hti;
1736
1737   hti = (struct mips_htab_traverse_info *) data;
1738   if (!hti->info->relocatable)
1739     mips_elf_check_mips16_stubs (hti->info, h);
1740
1741   if (mips_elf_local_pic_function_p (h))
1742     {
1743       /* PR 12845: If H is in a section that has been garbage
1744          collected it will have its output section set to *ABS*.  */
1745       if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1746         return TRUE;
1747
1748       /* H is a function that might need $25 to be valid on entry.
1749          If we're creating a non-PIC relocatable object, mark H as
1750          being PIC.  If we're creating a non-relocatable object with
1751          non-PIC branches and jumps to H, make sure that H has an la25
1752          stub.  */
1753       if (hti->info->relocatable)
1754         {
1755           if (!PIC_OBJECT_P (hti->output_bfd))
1756             h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
1757         }
1758       else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
1759         {
1760           hti->error = TRUE;
1761           return FALSE;
1762         }
1763     }
1764   return TRUE;
1765 }
1766 \f
1767 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1768    Most mips16 instructions are 16 bits, but these instructions
1769    are 32 bits.
1770
1771    The format of these instructions is:
1772
1773    +--------------+--------------------------------+
1774    |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
1775    +--------------+--------------------------------+
1776    |                Immediate  15:0                |
1777    +-----------------------------------------------+
1778
1779    JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
1780    Note that the immediate value in the first word is swapped.
1781
1782    When producing a relocatable object file, R_MIPS16_26 is
1783    handled mostly like R_MIPS_26.  In particular, the addend is
1784    stored as a straight 26-bit value in a 32-bit instruction.
1785    (gas makes life simpler for itself by never adjusting a
1786    R_MIPS16_26 reloc to be against a section, so the addend is
1787    always zero).  However, the 32 bit instruction is stored as 2
1788    16-bit values, rather than a single 32-bit value.  In a
1789    big-endian file, the result is the same; in a little-endian
1790    file, the two 16-bit halves of the 32 bit value are swapped.
1791    This is so that a disassembler can recognize the jal
1792    instruction.
1793
1794    When doing a final link, R_MIPS16_26 is treated as a 32 bit
1795    instruction stored as two 16-bit values.  The addend A is the
1796    contents of the targ26 field.  The calculation is the same as
1797    R_MIPS_26.  When storing the calculated value, reorder the
1798    immediate value as shown above, and don't forget to store the
1799    value as two 16-bit values.
1800
1801    To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1802    defined as
1803
1804    big-endian:
1805    +--------+----------------------+
1806    |        |                      |
1807    |        |    targ26-16         |
1808    |31    26|25                   0|
1809    +--------+----------------------+
1810
1811    little-endian:
1812    +----------+------+-------------+
1813    |          |      |             |
1814    |  sub1    |      |     sub2    |
1815    |0        9|10  15|16         31|
1816    +----------+--------------------+
1817    where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1818    ((sub1 << 16) | sub2)).
1819
1820    When producing a relocatable object file, the calculation is
1821    (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1822    When producing a fully linked file, the calculation is
1823    let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1824    ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1825
1826    The table below lists the other MIPS16 instruction relocations.
1827    Each one is calculated in the same way as the non-MIPS16 relocation
1828    given on the right, but using the extended MIPS16 layout of 16-bit
1829    immediate fields:
1830
1831         R_MIPS16_GPREL          R_MIPS_GPREL16
1832         R_MIPS16_GOT16          R_MIPS_GOT16
1833         R_MIPS16_CALL16         R_MIPS_CALL16
1834         R_MIPS16_HI16           R_MIPS_HI16
1835         R_MIPS16_LO16           R_MIPS_LO16
1836
1837    A typical instruction will have a format like this:
1838
1839    +--------------+--------------------------------+
1840    |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
1841    +--------------+--------------------------------+
1842    |    Major     |   rx   |   ry   |   Imm  4:0   |
1843    +--------------+--------------------------------+
1844
1845    EXTEND is the five bit value 11110.  Major is the instruction
1846    opcode.
1847
1848    All we need to do here is shuffle the bits appropriately.
1849    As above, the two 16-bit halves must be swapped on a
1850    little-endian system.  */
1851
1852 static inline bfd_boolean
1853 mips16_reloc_p (int r_type)
1854 {
1855   switch (r_type)
1856     {
1857     case R_MIPS16_26:
1858     case R_MIPS16_GPREL:
1859     case R_MIPS16_GOT16:
1860     case R_MIPS16_CALL16:
1861     case R_MIPS16_HI16:
1862     case R_MIPS16_LO16:
1863       return TRUE;
1864
1865     default:
1866       return FALSE;
1867     }
1868 }
1869
1870 /* Check if a microMIPS reloc.  */
1871
1872 static inline bfd_boolean
1873 micromips_reloc_p (unsigned int r_type)
1874 {
1875   return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
1876 }
1877
1878 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
1879    on a little-endian system.  This does not apply to R_MICROMIPS_PC7_S1
1880    and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.  */
1881
1882 static inline bfd_boolean
1883 micromips_reloc_shuffle_p (unsigned int r_type)
1884 {
1885   return (micromips_reloc_p (r_type)
1886           && r_type != R_MICROMIPS_PC7_S1
1887           && r_type != R_MICROMIPS_PC10_S1);
1888 }
1889
1890 static inline bfd_boolean
1891 got16_reloc_p (int r_type)
1892 {
1893   return (r_type == R_MIPS_GOT16
1894           || r_type == R_MIPS16_GOT16
1895           || r_type == R_MICROMIPS_GOT16);
1896 }
1897
1898 static inline bfd_boolean
1899 call16_reloc_p (int r_type)
1900 {
1901   return (r_type == R_MIPS_CALL16
1902           || r_type == R_MIPS16_CALL16
1903           || r_type == R_MICROMIPS_CALL16);
1904 }
1905
1906 static inline bfd_boolean
1907 got_disp_reloc_p (unsigned int r_type)
1908 {
1909   return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
1910 }
1911
1912 static inline bfd_boolean
1913 got_page_reloc_p (unsigned int r_type)
1914 {
1915   return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
1916 }
1917
1918 static inline bfd_boolean
1919 got_ofst_reloc_p (unsigned int r_type)
1920 {
1921   return r_type == R_MIPS_GOT_OFST || r_type == R_MICROMIPS_GOT_OFST;
1922 }
1923
1924 static inline bfd_boolean
1925 got_hi16_reloc_p (unsigned int r_type)
1926 {
1927   return r_type == R_MIPS_GOT_HI16 || r_type == R_MICROMIPS_GOT_HI16;
1928 }
1929
1930 static inline bfd_boolean
1931 got_lo16_reloc_p (unsigned int r_type)
1932 {
1933   return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
1934 }
1935
1936 static inline bfd_boolean
1937 call_hi16_reloc_p (unsigned int r_type)
1938 {
1939   return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
1940 }
1941
1942 static inline bfd_boolean
1943 call_lo16_reloc_p (unsigned int r_type)
1944 {
1945   return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
1946 }
1947
1948 static inline bfd_boolean
1949 hi16_reloc_p (int r_type)
1950 {
1951   return (r_type == R_MIPS_HI16
1952           || r_type == R_MIPS16_HI16
1953           || r_type == R_MICROMIPS_HI16);
1954 }
1955
1956 static inline bfd_boolean
1957 lo16_reloc_p (int r_type)
1958 {
1959   return (r_type == R_MIPS_LO16
1960           || r_type == R_MIPS16_LO16
1961           || r_type == R_MICROMIPS_LO16);
1962 }
1963
1964 static inline bfd_boolean
1965 mips16_call_reloc_p (int r_type)
1966 {
1967   return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
1968 }
1969
1970 static inline bfd_boolean
1971 jal_reloc_p (int r_type)
1972 {
1973   return (r_type == R_MIPS_26
1974           || r_type == R_MIPS16_26
1975           || r_type == R_MICROMIPS_26_S1);
1976 }
1977
1978 static inline bfd_boolean
1979 micromips_branch_reloc_p (int r_type)
1980 {
1981   return (r_type == R_MICROMIPS_26_S1
1982           || r_type == R_MICROMIPS_PC16_S1
1983           || r_type == R_MICROMIPS_PC10_S1
1984           || r_type == R_MICROMIPS_PC7_S1);
1985 }
1986
1987 static inline bfd_boolean
1988 tls_gd_reloc_p (unsigned int r_type)
1989 {
1990   return r_type == R_MIPS_TLS_GD || r_type == R_MICROMIPS_TLS_GD;
1991 }
1992
1993 static inline bfd_boolean
1994 tls_ldm_reloc_p (unsigned int r_type)
1995 {
1996   return r_type == R_MIPS_TLS_LDM || r_type == R_MICROMIPS_TLS_LDM;
1997 }
1998
1999 static inline bfd_boolean
2000 tls_gottprel_reloc_p (unsigned int r_type)
2001 {
2002   return r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MICROMIPS_TLS_GOTTPREL;
2003 }
2004
2005 void
2006 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2007                                bfd_boolean jal_shuffle, bfd_byte *data)
2008 {
2009   bfd_vma first, second, val;
2010
2011   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2012     return;
2013
2014   /* Pick up the first and second halfwords of the instruction.  */
2015   first = bfd_get_16 (abfd, data);
2016   second = bfd_get_16 (abfd, data + 2);
2017   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2018     val = first << 16 | second;
2019   else if (r_type != R_MIPS16_26)
2020     val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2021            | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2022   else
2023     val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2024            | ((first & 0x1f) << 21) | second);
2025   bfd_put_32 (abfd, val, data);
2026 }
2027
2028 void
2029 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2030                              bfd_boolean jal_shuffle, bfd_byte *data)
2031 {
2032   bfd_vma first, second, val;
2033
2034   if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2035     return;
2036
2037   val = bfd_get_32 (abfd, data);
2038   if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2039     {
2040       second = val & 0xffff;
2041       first = val >> 16;
2042     }
2043   else if (r_type != R_MIPS16_26)
2044     {
2045       second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2046       first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2047     }
2048   else
2049     {
2050       second = val & 0xffff;
2051       first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2052                | ((val >> 21) & 0x1f);
2053     }
2054   bfd_put_16 (abfd, second, data + 2);
2055   bfd_put_16 (abfd, first, data);
2056 }
2057
2058 bfd_reloc_status_type
2059 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2060                                arelent *reloc_entry, asection *input_section,
2061                                bfd_boolean relocatable, void *data, bfd_vma gp)
2062 {
2063   bfd_vma relocation;
2064   bfd_signed_vma val;
2065   bfd_reloc_status_type status;
2066
2067   if (bfd_is_com_section (symbol->section))
2068     relocation = 0;
2069   else
2070     relocation = symbol->value;
2071
2072   relocation += symbol->section->output_section->vma;
2073   relocation += symbol->section->output_offset;
2074
2075   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2076     return bfd_reloc_outofrange;
2077
2078   /* Set val to the offset into the section or symbol.  */
2079   val = reloc_entry->addend;
2080
2081   _bfd_mips_elf_sign_extend (val, 16);
2082
2083   /* Adjust val for the final section location and GP value.  If we
2084      are producing relocatable output, we don't want to do this for
2085      an external symbol.  */
2086   if (! relocatable
2087       || (symbol->flags & BSF_SECTION_SYM) != 0)
2088     val += relocation - gp;
2089
2090   if (reloc_entry->howto->partial_inplace)
2091     {
2092       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2093                                        (bfd_byte *) data
2094                                        + reloc_entry->address);
2095       if (status != bfd_reloc_ok)
2096         return status;
2097     }
2098   else
2099     reloc_entry->addend = val;
2100
2101   if (relocatable)
2102     reloc_entry->address += input_section->output_offset;
2103
2104   return bfd_reloc_ok;
2105 }
2106
2107 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2108    R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
2109    that contains the relocation field and DATA points to the start of
2110    INPUT_SECTION.  */
2111
2112 struct mips_hi16
2113 {
2114   struct mips_hi16 *next;
2115   bfd_byte *data;
2116   asection *input_section;
2117   arelent rel;
2118 };
2119
2120 /* FIXME: This should not be a static variable.  */
2121
2122 static struct mips_hi16 *mips_hi16_list;
2123
2124 /* A howto special_function for REL *HI16 relocations.  We can only
2125    calculate the correct value once we've seen the partnering
2126    *LO16 relocation, so just save the information for later.
2127
2128    The ABI requires that the *LO16 immediately follow the *HI16.
2129    However, as a GNU extension, we permit an arbitrary number of
2130    *HI16s to be associated with a single *LO16.  This significantly
2131    simplies the relocation handling in gcc.  */
2132
2133 bfd_reloc_status_type
2134 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2135                           asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2136                           asection *input_section, bfd *output_bfd,
2137                           char **error_message ATTRIBUTE_UNUSED)
2138 {
2139   struct mips_hi16 *n;
2140
2141   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2142     return bfd_reloc_outofrange;
2143
2144   n = bfd_malloc (sizeof *n);
2145   if (n == NULL)
2146     return bfd_reloc_outofrange;
2147
2148   n->next = mips_hi16_list;
2149   n->data = data;
2150   n->input_section = input_section;
2151   n->rel = *reloc_entry;
2152   mips_hi16_list = n;
2153
2154   if (output_bfd != NULL)
2155     reloc_entry->address += input_section->output_offset;
2156
2157   return bfd_reloc_ok;
2158 }
2159
2160 /* A howto special_function for REL R_MIPS*_GOT16 relocations.  This is just
2161    like any other 16-bit relocation when applied to global symbols, but is
2162    treated in the same as R_MIPS_HI16 when applied to local symbols.  */
2163
2164 bfd_reloc_status_type
2165 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2166                            void *data, asection *input_section,
2167                            bfd *output_bfd, char **error_message)
2168 {
2169   if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2170       || bfd_is_und_section (bfd_get_section (symbol))
2171       || bfd_is_com_section (bfd_get_section (symbol)))
2172     /* The relocation is against a global symbol.  */
2173     return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2174                                         input_section, output_bfd,
2175                                         error_message);
2176
2177   return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2178                                    input_section, output_bfd, error_message);
2179 }
2180
2181 /* A howto special_function for REL *LO16 relocations.  The *LO16 itself
2182    is a straightforward 16 bit inplace relocation, but we must deal with
2183    any partnering high-part relocations as well.  */
2184
2185 bfd_reloc_status_type
2186 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2187                           void *data, asection *input_section,
2188                           bfd *output_bfd, char **error_message)
2189 {
2190   bfd_vma vallo;
2191   bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2192
2193   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2194     return bfd_reloc_outofrange;
2195
2196   _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2197                                  location);
2198   vallo = bfd_get_32 (abfd, location);
2199   _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2200                                location);
2201
2202   while (mips_hi16_list != NULL)
2203     {
2204       bfd_reloc_status_type ret;
2205       struct mips_hi16 *hi;
2206
2207       hi = mips_hi16_list;
2208
2209       /* R_MIPS*_GOT16 relocations are something of a special case.  We
2210          want to install the addend in the same way as for a R_MIPS*_HI16
2211          relocation (with a rightshift of 16).  However, since GOT16
2212          relocations can also be used with global symbols, their howto
2213          has a rightshift of 0.  */
2214       if (hi->rel.howto->type == R_MIPS_GOT16)
2215         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2216       else if (hi->rel.howto->type == R_MIPS16_GOT16)
2217         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2218       else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2219         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2220
2221       /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
2222          carry or borrow will induce a change of +1 or -1 in the high part.  */
2223       hi->rel.addend += (vallo + 0x8000) & 0xffff;
2224
2225       ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2226                                          hi->input_section, output_bfd,
2227                                          error_message);
2228       if (ret != bfd_reloc_ok)
2229         return ret;
2230
2231       mips_hi16_list = hi->next;
2232       free (hi);
2233     }
2234
2235   return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2236                                       input_section, output_bfd,
2237                                       error_message);
2238 }
2239
2240 /* A generic howto special_function.  This calculates and installs the
2241    relocation itself, thus avoiding the oft-discussed problems in
2242    bfd_perform_relocation and bfd_install_relocation.  */
2243
2244 bfd_reloc_status_type
2245 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2246                              asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2247                              asection *input_section, bfd *output_bfd,
2248                              char **error_message ATTRIBUTE_UNUSED)
2249 {
2250   bfd_signed_vma val;
2251   bfd_reloc_status_type status;
2252   bfd_boolean relocatable;
2253
2254   relocatable = (output_bfd != NULL);
2255
2256   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2257     return bfd_reloc_outofrange;
2258
2259   /* Build up the field adjustment in VAL.  */
2260   val = 0;
2261   if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2262     {
2263       /* Either we're calculating the final field value or we have a
2264          relocation against a section symbol.  Add in the section's
2265          offset or address.  */
2266       val += symbol->section->output_section->vma;
2267       val += symbol->section->output_offset;
2268     }
2269
2270   if (!relocatable)
2271     {
2272       /* We're calculating the final field value.  Add in the symbol's value
2273          and, if pc-relative, subtract the address of the field itself.  */
2274       val += symbol->value;
2275       if (reloc_entry->howto->pc_relative)
2276         {
2277           val -= input_section->output_section->vma;
2278           val -= input_section->output_offset;
2279           val -= reloc_entry->address;
2280         }
2281     }
2282
2283   /* VAL is now the final adjustment.  If we're keeping this relocation
2284      in the output file, and if the relocation uses a separate addend,
2285      we just need to add VAL to that addend.  Otherwise we need to add
2286      VAL to the relocation field itself.  */
2287   if (relocatable && !reloc_entry->howto->partial_inplace)
2288     reloc_entry->addend += val;
2289   else
2290     {
2291       bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2292
2293       /* Add in the separate addend, if any.  */
2294       val += reloc_entry->addend;
2295
2296       /* Add VAL to the relocation field.  */
2297       _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2298                                      location);
2299       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2300                                        location);
2301       _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2302                                    location);
2303
2304       if (status != bfd_reloc_ok)
2305         return status;
2306     }
2307
2308   if (relocatable)
2309     reloc_entry->address += input_section->output_offset;
2310
2311   return bfd_reloc_ok;
2312 }
2313 \f
2314 /* Swap an entry in a .gptab section.  Note that these routines rely
2315    on the equivalence of the two elements of the union.  */
2316
2317 static void
2318 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2319                               Elf32_gptab *in)
2320 {
2321   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2322   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2323 }
2324
2325 static void
2326 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2327                                Elf32_External_gptab *ex)
2328 {
2329   H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2330   H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2331 }
2332
2333 static void
2334 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2335                                 Elf32_External_compact_rel *ex)
2336 {
2337   H_PUT_32 (abfd, in->id1, ex->id1);
2338   H_PUT_32 (abfd, in->num, ex->num);
2339   H_PUT_32 (abfd, in->id2, ex->id2);
2340   H_PUT_32 (abfd, in->offset, ex->offset);
2341   H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2342   H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2343 }
2344
2345 static void
2346 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2347                            Elf32_External_crinfo *ex)
2348 {
2349   unsigned long l;
2350
2351   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2352        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2353        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2354        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2355   H_PUT_32 (abfd, l, ex->info);
2356   H_PUT_32 (abfd, in->konst, ex->konst);
2357   H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2358 }
2359 \f
2360 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
2361    routines swap this structure in and out.  They are used outside of
2362    BFD, so they are globally visible.  */
2363
2364 void
2365 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2366                                 Elf32_RegInfo *in)
2367 {
2368   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2369   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2370   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2371   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2372   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2373   in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2374 }
2375
2376 void
2377 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2378                                  Elf32_External_RegInfo *ex)
2379 {
2380   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2381   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2382   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2383   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2384   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2385   H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2386 }
2387
2388 /* In the 64 bit ABI, the .MIPS.options section holds register
2389    information in an Elf64_Reginfo structure.  These routines swap
2390    them in and out.  They are globally visible because they are used
2391    outside of BFD.  These routines are here so that gas can call them
2392    without worrying about whether the 64 bit ABI has been included.  */
2393
2394 void
2395 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2396                                 Elf64_Internal_RegInfo *in)
2397 {
2398   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2399   in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2400   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2401   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2402   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2403   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2404   in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2405 }
2406
2407 void
2408 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2409                                  Elf64_External_RegInfo *ex)
2410 {
2411   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2412   H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2413   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2414   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2415   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2416   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2417   H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2418 }
2419
2420 /* Swap in an options header.  */
2421
2422 void
2423 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2424                               Elf_Internal_Options *in)
2425 {
2426   in->kind = H_GET_8 (abfd, ex->kind);
2427   in->size = H_GET_8 (abfd, ex->size);
2428   in->section = H_GET_16 (abfd, ex->section);
2429   in->info = H_GET_32 (abfd, ex->info);
2430 }
2431
2432 /* Swap out an options header.  */
2433
2434 void
2435 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2436                                Elf_External_Options *ex)
2437 {
2438   H_PUT_8 (abfd, in->kind, ex->kind);
2439   H_PUT_8 (abfd, in->size, ex->size);
2440   H_PUT_16 (abfd, in->section, ex->section);
2441   H_PUT_32 (abfd, in->info, ex->info);
2442 }
2443 \f
2444 /* This function is called via qsort() to sort the dynamic relocation
2445    entries by increasing r_symndx value.  */
2446
2447 static int
2448 sort_dynamic_relocs (const void *arg1, const void *arg2)
2449 {
2450   Elf_Internal_Rela int_reloc1;
2451   Elf_Internal_Rela int_reloc2;
2452   int diff;
2453
2454   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2455   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2456
2457   diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2458   if (diff != 0)
2459     return diff;
2460
2461   if (int_reloc1.r_offset < int_reloc2.r_offset)
2462     return -1;
2463   if (int_reloc1.r_offset > int_reloc2.r_offset)
2464     return 1;
2465   return 0;
2466 }
2467
2468 /* Like sort_dynamic_relocs, but used for elf64 relocations.  */
2469
2470 static int
2471 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2472                         const void *arg2 ATTRIBUTE_UNUSED)
2473 {
2474 #ifdef BFD64
2475   Elf_Internal_Rela int_reloc1[3];
2476   Elf_Internal_Rela int_reloc2[3];
2477
2478   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2479     (reldyn_sorting_bfd, arg1, int_reloc1);
2480   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2481     (reldyn_sorting_bfd, arg2, int_reloc2);
2482
2483   if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2484     return -1;
2485   if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2486     return 1;
2487
2488   if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2489     return -1;
2490   if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2491     return 1;
2492   return 0;
2493 #else
2494   abort ();
2495 #endif
2496 }
2497
2498
2499 /* This routine is used to write out ECOFF debugging external symbol
2500    information.  It is called via mips_elf_link_hash_traverse.  The
2501    ECOFF external symbol information must match the ELF external
2502    symbol information.  Unfortunately, at this point we don't know
2503    whether a symbol is required by reloc information, so the two
2504    tables may wind up being different.  We must sort out the external
2505    symbol information before we can set the final size of the .mdebug
2506    section, and we must set the size of the .mdebug section before we
2507    can relocate any sections, and we can't know which symbols are
2508    required by relocation until we relocate the sections.
2509    Fortunately, it is relatively unlikely that any symbol will be
2510    stripped but required by a reloc.  In particular, it can not happen
2511    when generating a final executable.  */
2512
2513 static bfd_boolean
2514 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2515 {
2516   struct extsym_info *einfo = data;
2517   bfd_boolean strip;
2518   asection *sec, *output_section;
2519
2520   if (h->root.indx == -2)
2521     strip = FALSE;
2522   else if ((h->root.def_dynamic
2523             || h->root.ref_dynamic
2524             || h->root.type == bfd_link_hash_new)
2525            && !h->root.def_regular
2526            && !h->root.ref_regular)
2527     strip = TRUE;
2528   else if (einfo->info->strip == strip_all
2529            || (einfo->info->strip == strip_some
2530                && bfd_hash_lookup (einfo->info->keep_hash,
2531                                    h->root.root.root.string,
2532                                    FALSE, FALSE) == NULL))
2533     strip = TRUE;
2534   else
2535     strip = FALSE;
2536
2537   if (strip)
2538     return TRUE;
2539
2540   if (h->esym.ifd == -2)
2541     {
2542       h->esym.jmptbl = 0;
2543       h->esym.cobol_main = 0;
2544       h->esym.weakext = 0;
2545       h->esym.reserved = 0;
2546       h->esym.ifd = ifdNil;
2547       h->esym.asym.value = 0;
2548       h->esym.asym.st = stGlobal;
2549
2550       if (h->root.root.type == bfd_link_hash_undefined
2551           || h->root.root.type == bfd_link_hash_undefweak)
2552         {
2553           const char *name;
2554
2555           /* Use undefined class.  Also, set class and type for some
2556              special symbols.  */
2557           name = h->root.root.root.string;
2558           if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2559               || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2560             {
2561               h->esym.asym.sc = scData;
2562               h->esym.asym.st = stLabel;
2563               h->esym.asym.value = 0;
2564             }
2565           else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2566             {
2567               h->esym.asym.sc = scAbs;
2568               h->esym.asym.st = stLabel;
2569               h->esym.asym.value =
2570                 mips_elf_hash_table (einfo->info)->procedure_count;
2571             }
2572           else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2573             {
2574               h->esym.asym.sc = scAbs;
2575               h->esym.asym.st = stLabel;
2576               h->esym.asym.value = elf_gp (einfo->abfd);
2577             }
2578           else
2579             h->esym.asym.sc = scUndefined;
2580         }
2581       else if (h->root.root.type != bfd_link_hash_defined
2582           && h->root.root.type != bfd_link_hash_defweak)
2583         h->esym.asym.sc = scAbs;
2584       else
2585         {
2586           const char *name;
2587
2588           sec = h->root.root.u.def.section;
2589           output_section = sec->output_section;
2590
2591           /* When making a shared library and symbol h is the one from
2592              the another shared library, OUTPUT_SECTION may be null.  */
2593           if (output_section == NULL)
2594             h->esym.asym.sc = scUndefined;
2595           else
2596             {
2597               name = bfd_section_name (output_section->owner, output_section);
2598
2599               if (strcmp (name, ".text") == 0)
2600                 h->esym.asym.sc = scText;
2601               else if (strcmp (name, ".data") == 0)
2602                 h->esym.asym.sc = scData;
2603               else if (strcmp (name, ".sdata") == 0)
2604                 h->esym.asym.sc = scSData;
2605               else if (strcmp (name, ".rodata") == 0
2606                        || strcmp (name, ".rdata") == 0)
2607                 h->esym.asym.sc = scRData;
2608               else if (strcmp (name, ".bss") == 0)
2609                 h->esym.asym.sc = scBss;
2610               else if (strcmp (name, ".sbss") == 0)
2611                 h->esym.asym.sc = scSBss;
2612               else if (strcmp (name, ".init") == 0)
2613                 h->esym.asym.sc = scInit;
2614               else if (strcmp (name, ".fini") == 0)
2615                 h->esym.asym.sc = scFini;
2616               else
2617                 h->esym.asym.sc = scAbs;
2618             }
2619         }
2620
2621       h->esym.asym.reserved = 0;
2622       h->esym.asym.index = indexNil;
2623     }
2624
2625   if (h->root.root.type == bfd_link_hash_common)
2626     h->esym.asym.value = h->root.root.u.c.size;
2627   else if (h->root.root.type == bfd_link_hash_defined
2628            || h->root.root.type == bfd_link_hash_defweak)
2629     {
2630       if (h->esym.asym.sc == scCommon)
2631         h->esym.asym.sc = scBss;
2632       else if (h->esym.asym.sc == scSCommon)
2633         h->esym.asym.sc = scSBss;
2634
2635       sec = h->root.root.u.def.section;
2636       output_section = sec->output_section;
2637       if (output_section != NULL)
2638         h->esym.asym.value = (h->root.root.u.def.value
2639                               + sec->output_offset
2640                               + output_section->vma);
2641       else
2642         h->esym.asym.value = 0;
2643     }
2644   else
2645     {
2646       struct mips_elf_link_hash_entry *hd = h;
2647
2648       while (hd->root.root.type == bfd_link_hash_indirect)
2649         hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2650
2651       if (hd->needs_lazy_stub)
2652         {
2653           /* Set type and value for a symbol with a function stub.  */
2654           h->esym.asym.st = stProc;
2655           sec = hd->root.root.u.def.section;
2656           if (sec == NULL)
2657             h->esym.asym.value = 0;
2658           else
2659             {
2660               output_section = sec->output_section;
2661               if (output_section != NULL)
2662                 h->esym.asym.value = (hd->root.plt.offset
2663                                       + sec->output_offset
2664                                       + output_section->vma);
2665               else
2666                 h->esym.asym.value = 0;
2667             }
2668         }
2669     }
2670
2671   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2672                                       h->root.root.root.string,
2673                                       &h->esym))
2674     {
2675       einfo->failed = TRUE;
2676       return FALSE;
2677     }
2678
2679   return TRUE;
2680 }
2681
2682 /* A comparison routine used to sort .gptab entries.  */
2683
2684 static int
2685 gptab_compare (const void *p1, const void *p2)
2686 {
2687   const Elf32_gptab *a1 = p1;
2688   const Elf32_gptab *a2 = p2;
2689
2690   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
2691 }
2692 \f
2693 /* Functions to manage the got entry hash table.  */
2694
2695 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2696    hash number.  */
2697
2698 static INLINE hashval_t
2699 mips_elf_hash_bfd_vma (bfd_vma addr)
2700 {
2701 #ifdef BFD64
2702   return addr + (addr >> 32);
2703 #else
2704   return addr;
2705 #endif
2706 }
2707
2708 /* got_entries only match if they're identical, except for gotidx, so
2709    use all fields to compute the hash, and compare the appropriate
2710    union members.  */
2711
2712 static hashval_t
2713 mips_elf_got_entry_hash (const void *entry_)
2714 {
2715   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2716
2717   return entry->symndx
2718     + ((entry->tls_type & GOT_TLS_LDM) << 17)
2719     + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2720        : entry->abfd->id
2721          + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2722             : entry->d.h->root.root.root.hash));
2723 }
2724
2725 static int
2726 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2727 {
2728   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2729   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2730
2731   /* An LDM entry can only match another LDM entry.  */
2732   if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2733     return 0;
2734
2735   return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2736     && (! e1->abfd ? e1->d.address == e2->d.address
2737         : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2738         : e1->d.h == e2->d.h);
2739 }
2740
2741 /* multi_got_entries are still a match in the case of global objects,
2742    even if the input bfd in which they're referenced differs, so the
2743    hash computation and compare functions are adjusted
2744    accordingly.  */
2745
2746 static hashval_t
2747 mips_elf_multi_got_entry_hash (const void *entry_)
2748 {
2749   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2750
2751   return entry->symndx
2752     + (! entry->abfd
2753        ? mips_elf_hash_bfd_vma (entry->d.address)
2754        : entry->symndx >= 0
2755        ? ((entry->tls_type & GOT_TLS_LDM)
2756           ? (GOT_TLS_LDM << 17)
2757           : (entry->abfd->id
2758              + mips_elf_hash_bfd_vma (entry->d.addend)))
2759        : entry->d.h->root.root.root.hash);
2760 }
2761
2762 static int
2763 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2764 {
2765   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2766   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2767
2768   /* Any two LDM entries match.  */
2769   if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2770     return 1;
2771
2772   /* Nothing else matches an LDM entry.  */
2773   if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2774     return 0;
2775
2776   return e1->symndx == e2->symndx
2777     && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2778         : e1->abfd == NULL || e2->abfd == NULL
2779         ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2780         : e1->d.h == e2->d.h);
2781 }
2782
2783 static hashval_t
2784 mips_got_page_entry_hash (const void *entry_)
2785 {
2786   const struct mips_got_page_entry *entry;
2787
2788   entry = (const struct mips_got_page_entry *) entry_;
2789   return entry->abfd->id + entry->symndx;
2790 }
2791
2792 static int
2793 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2794 {
2795   const struct mips_got_page_entry *entry1, *entry2;
2796
2797   entry1 = (const struct mips_got_page_entry *) entry1_;
2798   entry2 = (const struct mips_got_page_entry *) entry2_;
2799   return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2800 }
2801 \f
2802 /* Return the dynamic relocation section.  If it doesn't exist, try to
2803    create a new it if CREATE_P, otherwise return NULL.  Also return NULL
2804    if creation fails.  */
2805
2806 static asection *
2807 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2808 {
2809   const char *dname;
2810   asection *sreloc;
2811   bfd *dynobj;
2812
2813   dname = MIPS_ELF_REL_DYN_NAME (info);
2814   dynobj = elf_hash_table (info)->dynobj;
2815   sreloc = bfd_get_section_by_name (dynobj, dname);
2816   if (sreloc == NULL && create_p)
2817     {
2818       sreloc = bfd_make_section_with_flags (dynobj, dname,
2819                                             (SEC_ALLOC
2820                                              | SEC_LOAD
2821                                              | SEC_HAS_CONTENTS
2822                                              | SEC_IN_MEMORY
2823                                              | SEC_LINKER_CREATED
2824                                              | SEC_READONLY));
2825       if (sreloc == NULL
2826           || ! bfd_set_section_alignment (dynobj, sreloc,
2827                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2828         return NULL;
2829     }
2830   return sreloc;
2831 }
2832
2833 /* Count the number of relocations needed for a TLS GOT entry, with
2834    access types from TLS_TYPE, and symbol H (or a local symbol if H
2835    is NULL).  */
2836
2837 static int
2838 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2839                      struct elf_link_hash_entry *h)
2840 {
2841   int indx = 0;
2842   int ret = 0;
2843   bfd_boolean need_relocs = FALSE;
2844   bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2845
2846   if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2847       && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2848     indx = h->dynindx;
2849
2850   if ((info->shared || indx != 0)
2851       && (h == NULL
2852           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2853           || h->root.type != bfd_link_hash_undefweak))
2854     need_relocs = TRUE;
2855
2856   if (!need_relocs)
2857     return FALSE;
2858
2859   if (tls_type & GOT_TLS_GD)
2860     {
2861       ret++;
2862       if (indx != 0)
2863         ret++;
2864     }
2865
2866   if (tls_type & GOT_TLS_IE)
2867     ret++;
2868
2869   if ((tls_type & GOT_TLS_LDM) && info->shared)
2870     ret++;
2871
2872   return ret;
2873 }
2874
2875 /* Count the number of TLS relocations required for the GOT entry in
2876    ARG1, if it describes a local symbol.  */
2877
2878 static int
2879 mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2880 {
2881   struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2882   struct mips_elf_count_tls_arg *arg = arg2;
2883
2884   if (entry->abfd != NULL && entry->symndx != -1)
2885     arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2886
2887   return 1;
2888 }
2889
2890 /* Count the number of TLS GOT entries required for the global (or
2891    forced-local) symbol in ARG1.  */
2892
2893 static int
2894 mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2895 {
2896   struct mips_elf_link_hash_entry *hm
2897     = (struct mips_elf_link_hash_entry *) arg1;
2898   struct mips_elf_count_tls_arg *arg = arg2;
2899
2900   if (hm->tls_type & GOT_TLS_GD)
2901     arg->needed += 2;
2902   if (hm->tls_type & GOT_TLS_IE)
2903     arg->needed += 1;
2904
2905   return 1;
2906 }
2907
2908 /* Count the number of TLS relocations required for the global (or
2909    forced-local) symbol in ARG1.  */
2910
2911 static int
2912 mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2913 {
2914   struct mips_elf_link_hash_entry *hm
2915     = (struct mips_elf_link_hash_entry *) arg1;
2916   struct mips_elf_count_tls_arg *arg = arg2;
2917
2918   arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2919
2920   return 1;
2921 }
2922
2923 /* Output a simple dynamic relocation into SRELOC.  */
2924
2925 static void
2926 mips_elf_output_dynamic_relocation (bfd *output_bfd,
2927                                     asection *sreloc,
2928                                     unsigned long reloc_index,
2929                                     unsigned long indx,
2930                                     int r_type,
2931                                     bfd_vma offset)
2932 {
2933   Elf_Internal_Rela rel[3];
2934
2935   memset (rel, 0, sizeof (rel));
2936
2937   rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
2938   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
2939
2940   if (ABI_64_P (output_bfd))
2941     {
2942       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
2943         (output_bfd, &rel[0],
2944          (sreloc->contents
2945           + reloc_index * sizeof (Elf64_Mips_External_Rel)));
2946     }
2947   else
2948     bfd_elf32_swap_reloc_out
2949       (output_bfd, &rel[0],
2950        (sreloc->contents
2951         + reloc_index * sizeof (Elf32_External_Rel)));
2952 }
2953
2954 /* Initialize a set of TLS GOT entries for one symbol.  */
2955
2956 static void
2957 mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
2958                                unsigned char *tls_type_p,
2959                                struct bfd_link_info *info,
2960                                struct mips_elf_link_hash_entry *h,
2961                                bfd_vma value)
2962 {
2963   struct mips_elf_link_hash_table *htab;
2964   int indx;
2965   asection *sreloc, *sgot;
2966   bfd_vma offset, offset2;
2967   bfd_boolean need_relocs = FALSE;
2968
2969   htab = mips_elf_hash_table (info);
2970   if (htab == NULL)
2971     return;
2972
2973   sgot = htab->sgot;
2974
2975   indx = 0;
2976   if (h != NULL)
2977     {
2978       bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2979
2980       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
2981           && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
2982         indx = h->root.dynindx;
2983     }
2984
2985   if (*tls_type_p & GOT_TLS_DONE)
2986     return;
2987
2988   if ((info->shared || indx != 0)
2989       && (h == NULL
2990           || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
2991           || h->root.type != bfd_link_hash_undefweak))
2992     need_relocs = TRUE;
2993
2994   /* MINUS_ONE means the symbol is not defined in this object.  It may not
2995      be defined at all; assume that the value doesn't matter in that
2996      case.  Otherwise complain if we would use the value.  */
2997   BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
2998               || h->root.root.type == bfd_link_hash_undefweak);
2999
3000   /* Emit necessary relocations.  */
3001   sreloc = mips_elf_rel_dyn_section (info, FALSE);
3002
3003   /* General Dynamic.  */
3004   if (*tls_type_p & GOT_TLS_GD)
3005     {
3006       offset = got_offset;
3007       offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
3008
3009       if (need_relocs)
3010         {
3011           mips_elf_output_dynamic_relocation
3012             (abfd, sreloc, sreloc->reloc_count++, indx,
3013              ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3014              sgot->output_offset + sgot->output_section->vma + offset);
3015
3016           if (indx)
3017             mips_elf_output_dynamic_relocation
3018               (abfd, sreloc, sreloc->reloc_count++, indx,
3019                ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3020                sgot->output_offset + sgot->output_section->vma + offset2);
3021           else
3022             MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3023                                sgot->contents + offset2);
3024         }
3025       else
3026         {
3027           MIPS_ELF_PUT_WORD (abfd, 1,
3028                              sgot->contents + offset);
3029           MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3030                              sgot->contents + offset2);
3031         }
3032
3033       got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
3034     }
3035
3036   /* Initial Exec model.  */
3037   if (*tls_type_p & GOT_TLS_IE)
3038     {
3039       offset = got_offset;
3040
3041       if (need_relocs)
3042         {
3043           if (indx == 0)
3044             MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3045                                sgot->contents + offset);
3046           else
3047             MIPS_ELF_PUT_WORD (abfd, 0,
3048                                sgot->contents + offset);
3049
3050           mips_elf_output_dynamic_relocation
3051             (abfd, sreloc, sreloc->reloc_count++, indx,
3052              ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3053              sgot->output_offset + sgot->output_section->vma + offset);
3054         }
3055       else
3056         MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3057                            sgot->contents + offset);
3058     }
3059
3060   if (*tls_type_p & GOT_TLS_LDM)
3061     {
3062       /* The initial offset is zero, and the LD offsets will include the
3063          bias by DTP_OFFSET.  */
3064       MIPS_ELF_PUT_WORD (abfd, 0,
3065                          sgot->contents + got_offset
3066                          + MIPS_ELF_GOT_SIZE (abfd));
3067
3068       if (!info->shared)
3069         MIPS_ELF_PUT_WORD (abfd, 1,
3070                            sgot->contents + got_offset);
3071       else
3072         mips_elf_output_dynamic_relocation
3073           (abfd, sreloc, sreloc->reloc_count++, indx,
3074            ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3075            sgot->output_offset + sgot->output_section->vma + got_offset);
3076     }
3077
3078   *tls_type_p |= GOT_TLS_DONE;
3079 }
3080
3081 /* Return the GOT index to use for a relocation of type R_TYPE against
3082    a symbol accessed using TLS_TYPE models.  The GOT entries for this
3083    symbol in this GOT start at GOT_INDEX.  This function initializes the
3084    GOT entries and corresponding relocations.  */
3085
3086 static bfd_vma
3087 mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
3088                     int r_type, struct bfd_link_info *info,
3089                     struct mips_elf_link_hash_entry *h, bfd_vma symbol)
3090 {
3091   BFD_ASSERT (tls_gottprel_reloc_p (r_type)
3092               || tls_gd_reloc_p (r_type)
3093               || tls_ldm_reloc_p (r_type));
3094
3095   mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
3096
3097   if (tls_gottprel_reloc_p (r_type))
3098     {
3099       BFD_ASSERT (*tls_type & GOT_TLS_IE);
3100       if (*tls_type & GOT_TLS_GD)
3101         return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
3102       else
3103         return got_index;
3104     }
3105
3106   if (tls_gd_reloc_p (r_type))
3107     {
3108       BFD_ASSERT (*tls_type & GOT_TLS_GD);
3109       return got_index;
3110     }
3111
3112   if (tls_ldm_reloc_p (r_type))
3113     {
3114       BFD_ASSERT (*tls_type & GOT_TLS_LDM);
3115       return got_index;
3116     }
3117
3118   return got_index;
3119 }
3120
3121 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3122    for global symbol H.  .got.plt comes before the GOT, so the offset
3123    will be negative.  */
3124
3125 static bfd_vma
3126 mips_elf_gotplt_index (struct bfd_link_info *info,
3127                        struct elf_link_hash_entry *h)
3128 {
3129   bfd_vma plt_index, got_address, got_value;
3130   struct mips_elf_link_hash_table *htab;
3131
3132   htab = mips_elf_hash_table (info);
3133   BFD_ASSERT (htab != NULL);
3134
3135   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
3136
3137   /* This function only works for VxWorks, because a non-VxWorks .got.plt
3138      section starts with reserved entries.  */
3139   BFD_ASSERT (htab->is_vxworks);
3140
3141   /* Calculate the index of the symbol's PLT entry.  */
3142   plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
3143
3144   /* Calculate the address of the associated .got.plt entry.  */
3145   got_address = (htab->sgotplt->output_section->vma
3146                  + htab->sgotplt->output_offset
3147                  + plt_index * 4);
3148
3149   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
3150   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3151                + htab->root.hgot->root.u.def.section->output_offset
3152                + htab->root.hgot->root.u.def.value);
3153
3154   return got_address - got_value;
3155 }
3156
3157 /* Return the GOT offset for address VALUE.   If there is not yet a GOT
3158    entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
3159    create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
3160    offset can be found.  */
3161
3162 static bfd_vma
3163 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3164                           bfd_vma value, unsigned long r_symndx,
3165                           struct mips_elf_link_hash_entry *h, int r_type)
3166 {
3167   struct mips_elf_link_hash_table *htab;
3168   struct mips_got_entry *entry;
3169
3170   htab = mips_elf_hash_table (info);
3171   BFD_ASSERT (htab != NULL);
3172
3173   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3174                                            r_symndx, h, r_type);
3175   if (!entry)
3176     return MINUS_ONE;
3177
3178   if (TLS_RELOC_P (r_type))
3179     {
3180       if (entry->symndx == -1 && htab->got_info->next == NULL)
3181         /* A type (3) entry in the single-GOT case.  We use the symbol's
3182            hash table entry to track the index.  */
3183         return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
3184                                    r_type, info, h, value);
3185       else
3186         return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
3187                                    r_type, info, h, value);
3188     }
3189   else
3190     return entry->gotidx;
3191 }
3192
3193 /* Returns the GOT index for the global symbol indicated by H.  */
3194
3195 static bfd_vma
3196 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
3197                            int r_type, struct bfd_link_info *info)
3198 {
3199   struct mips_elf_link_hash_table *htab;
3200   bfd_vma got_index;
3201   struct mips_got_info *g, *gg;
3202   long global_got_dynindx = 0;
3203
3204   htab = mips_elf_hash_table (info);
3205   BFD_ASSERT (htab != NULL);
3206
3207   gg = g = htab->got_info;
3208   if (g->bfd2got && ibfd)
3209     {
3210       struct mips_got_entry e, *p;
3211
3212       BFD_ASSERT (h->dynindx >= 0);
3213
3214       g = mips_elf_got_for_ibfd (g, ibfd);
3215       if (g->next != gg || TLS_RELOC_P (r_type))
3216         {
3217           e.abfd = ibfd;
3218           e.symndx = -1;
3219           e.d.h = (struct mips_elf_link_hash_entry *)h;
3220           e.tls_type = 0;
3221
3222           p = htab_find (g->got_entries, &e);
3223
3224           BFD_ASSERT (p->gotidx > 0);
3225
3226           if (TLS_RELOC_P (r_type))
3227             {
3228               bfd_vma value = MINUS_ONE;
3229               if ((h->root.type == bfd_link_hash_defined
3230                    || h->root.type == bfd_link_hash_defweak)
3231                   && h->root.u.def.section->output_section)
3232                 value = (h->root.u.def.value
3233                          + h->root.u.def.section->output_offset
3234                          + h->root.u.def.section->output_section->vma);
3235
3236               return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
3237                                          info, e.d.h, value);
3238             }
3239           else
3240             return p->gotidx;
3241         }
3242     }
3243
3244   if (gg->global_gotsym != NULL)
3245     global_got_dynindx = gg->global_gotsym->dynindx;
3246
3247   if (TLS_RELOC_P (r_type))
3248     {
3249       struct mips_elf_link_hash_entry *hm
3250         = (struct mips_elf_link_hash_entry *) h;
3251       bfd_vma value = MINUS_ONE;
3252
3253       if ((h->root.type == bfd_link_hash_defined
3254            || h->root.type == bfd_link_hash_defweak)
3255           && h->root.u.def.section->output_section)
3256         value = (h->root.u.def.value
3257                  + h->root.u.def.section->output_offset
3258                  + h->root.u.def.section->output_section->vma);
3259
3260       got_index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
3261                                       r_type, info, hm, value);
3262     }
3263   else
3264     {
3265       /* Once we determine the global GOT entry with the lowest dynamic
3266          symbol table index, we must put all dynamic symbols with greater
3267          indices into the GOT.  That makes it easy to calculate the GOT
3268          offset.  */
3269       BFD_ASSERT (h->dynindx >= global_got_dynindx);
3270       got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3271                    * MIPS_ELF_GOT_SIZE (abfd));
3272     }
3273   BFD_ASSERT (got_index < htab->sgot->size);
3274
3275   return got_index;
3276 }
3277
3278 /* Find a GOT page entry that points to within 32KB of VALUE.  These
3279    entries are supposed to be placed at small offsets in the GOT, i.e.,
3280    within 32KB of GP.  Return the index of the GOT entry, or -1 if no
3281    entry could be created.  If OFFSETP is nonnull, use it to return the
3282    offset of the GOT entry from VALUE.  */
3283
3284 static bfd_vma
3285 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3286                    bfd_vma value, bfd_vma *offsetp)
3287 {
3288   bfd_vma page, got_index;
3289   struct mips_got_entry *entry;
3290
3291   page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3292   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3293                                            NULL, R_MIPS_GOT_PAGE);
3294
3295   if (!entry)
3296     return MINUS_ONE;
3297
3298   got_index = entry->gotidx;
3299
3300   if (offsetp)
3301     *offsetp = value - entry->d.address;
3302
3303   return got_index;
3304 }
3305
3306 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3307    EXTERNAL is true if the relocation was originally against a global
3308    symbol that binds locally.  */
3309
3310 static bfd_vma
3311 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3312                       bfd_vma value, bfd_boolean external)
3313 {
3314   struct mips_got_entry *entry;
3315
3316   /* GOT16 relocations against local symbols are followed by a LO16
3317      relocation; those against global symbols are not.  Thus if the
3318      symbol was originally local, the GOT16 relocation should load the
3319      equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
3320   if (! external)
3321     value = mips_elf_high (value) << 16;
3322
3323   /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3324      R_MIPS16_GOT16, R_MIPS_CALL16, etc.  The format of the entry is the
3325      same in all cases.  */
3326   entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3327                                            NULL, R_MIPS_GOT16);
3328   if (entry)
3329     return entry->gotidx;
3330   else
3331     return MINUS_ONE;
3332 }
3333
3334 /* Returns the offset for the entry at the INDEXth position
3335    in the GOT.  */
3336
3337 static bfd_vma
3338 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3339                                 bfd *input_bfd, bfd_vma got_index)
3340 {
3341   struct mips_elf_link_hash_table *htab;
3342   asection *sgot;
3343   bfd_vma gp;
3344
3345   htab = mips_elf_hash_table (info);
3346   BFD_ASSERT (htab != NULL);
3347
3348   sgot = htab->sgot;
3349   gp = _bfd_get_gp_value (output_bfd)
3350     + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3351
3352   return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3353 }
3354
3355 /* Create and return a local GOT entry for VALUE, which was calculated
3356    from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
3357    be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
3358    instead.  */
3359
3360 static struct mips_got_entry *
3361 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3362                                  bfd *ibfd, bfd_vma value,
3363                                  unsigned long r_symndx,
3364                                  struct mips_elf_link_hash_entry *h,
3365                                  int r_type)
3366 {
3367   struct mips_got_entry entry, **loc;
3368   struct mips_got_info *g;
3369   struct mips_elf_link_hash_table *htab;
3370
3371   htab = mips_elf_hash_table (info);
3372   BFD_ASSERT (htab != NULL);
3373
3374   entry.abfd = NULL;
3375   entry.symndx = -1;
3376   entry.d.address = value;
3377   entry.tls_type = 0;
3378
3379   g = mips_elf_got_for_ibfd (htab->got_info, ibfd);
3380   if (g == NULL)
3381     {
3382       g = mips_elf_got_for_ibfd (htab->got_info, abfd);
3383       BFD_ASSERT (g != NULL);
3384     }
3385
3386   /* This function shouldn't be called for symbols that live in the global
3387      area of the GOT.  */
3388   BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3389   if (TLS_RELOC_P (r_type))
3390     {
3391       struct mips_got_entry *p;
3392
3393       entry.abfd = ibfd;
3394       if (tls_ldm_reloc_p (r_type))
3395         {
3396           entry.tls_type = GOT_TLS_LDM;
3397           entry.symndx = 0;
3398           entry.d.addend = 0;
3399         }
3400       else if (h == NULL)
3401         {
3402           entry.symndx = r_symndx;
3403           entry.d.addend = 0;
3404         }
3405       else
3406         entry.d.h = h;
3407
3408       p = (struct mips_got_entry *)
3409         htab_find (g->got_entries, &entry);
3410
3411       BFD_ASSERT (p);
3412       return p;
3413     }
3414
3415   loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3416                                                    INSERT);
3417   if (*loc)
3418     return *loc;
3419
3420   entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
3421   entry.tls_type = 0;
3422
3423   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3424
3425   if (! *loc)
3426     return NULL;
3427
3428   memcpy (*loc, &entry, sizeof entry);
3429
3430   if (g->assigned_gotno > g->local_gotno)
3431     {
3432       (*loc)->gotidx = -1;
3433       /* We didn't allocate enough space in the GOT.  */
3434       (*_bfd_error_handler)
3435         (_("not enough GOT space for local GOT entries"));
3436       bfd_set_error (bfd_error_bad_value);
3437       return NULL;
3438     }
3439
3440   MIPS_ELF_PUT_WORD (abfd, value,
3441                      (htab->sgot->contents + entry.gotidx));
3442
3443   /* These GOT entries need a dynamic relocation on VxWorks.  */
3444   if (htab->is_vxworks)
3445     {
3446       Elf_Internal_Rela outrel;
3447       asection *s;
3448       bfd_byte *rloc;
3449       bfd_vma got_address;
3450
3451       s = mips_elf_rel_dyn_section (info, FALSE);
3452       got_address = (htab->sgot->output_section->vma
3453                      + htab->sgot->output_offset
3454                      + entry.gotidx);
3455
3456       rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3457       outrel.r_offset = got_address;
3458       outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3459       outrel.r_addend = value;
3460       bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3461     }
3462
3463   return *loc;
3464 }
3465
3466 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3467    The number might be exact or a worst-case estimate, depending on how
3468    much information is available to elf_backend_omit_section_dynsym at
3469    the current linking stage.  */
3470
3471 static bfd_size_type
3472 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3473 {
3474   bfd_size_type count;
3475
3476   count = 0;
3477   if (info->shared || elf_hash_table (info)->is_relocatable_executable)
3478     {
3479       asection *p;
3480       const struct elf_backend_data *bed;
3481
3482       bed = get_elf_backend_data (output_bfd);
3483       for (p = output_bfd->sections; p ; p = p->next)
3484         if ((p->flags & SEC_EXCLUDE) == 0
3485             && (p->flags & SEC_ALLOC) != 0
3486             && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3487           ++count;
3488     }
3489   return count;
3490 }
3491
3492 /* Sort the dynamic symbol table so that symbols that need GOT entries
3493    appear towards the end.  */
3494
3495 static bfd_boolean
3496 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3497 {
3498   struct mips_elf_link_hash_table *htab;
3499   struct mips_elf_hash_sort_data hsd;
3500   struct mips_got_info *g;
3501
3502   if (elf_hash_table (info)->dynsymcount == 0)
3503     return TRUE;
3504
3505   htab = mips_elf_hash_table (info);
3506   BFD_ASSERT (htab != NULL);
3507
3508   g = htab->got_info;
3509   if (g == NULL)
3510     return TRUE;
3511
3512   hsd.low = NULL;
3513   hsd.max_unref_got_dynindx
3514     = hsd.min_got_dynindx
3515     = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
3516   hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
3517   mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3518                                 elf_hash_table (info)),
3519                                mips_elf_sort_hash_table_f,
3520                                &hsd);
3521
3522   /* There should have been enough room in the symbol table to
3523      accommodate both the GOT and non-GOT symbols.  */
3524   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3525   BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3526               == elf_hash_table (info)->dynsymcount);
3527   BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3528               == g->global_gotno);
3529
3530   /* Now we know which dynamic symbol has the lowest dynamic symbol
3531      table index in the GOT.  */
3532   g->global_gotsym = hsd.low;
3533
3534   return TRUE;
3535 }
3536
3537 /* If H needs a GOT entry, assign it the highest available dynamic
3538    index.  Otherwise, assign it the lowest available dynamic
3539    index.  */
3540
3541 static bfd_boolean
3542 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3543 {
3544   struct mips_elf_hash_sort_data *hsd = data;
3545
3546   /* Symbols without dynamic symbol table entries aren't interesting
3547      at all.  */
3548   if (h->root.dynindx == -1)
3549     return TRUE;
3550
3551   switch (h->global_got_area)
3552     {
3553     case GGA_NONE:
3554       h->root.dynindx = hsd->max_non_got_dynindx++;
3555       break;
3556
3557     case GGA_NORMAL:
3558       BFD_ASSERT (h->tls_type == GOT_NORMAL);
3559
3560       h->root.dynindx = --hsd->min_got_dynindx;
3561       hsd->low = (struct elf_link_hash_entry *) h;
3562       break;
3563
3564     case GGA_RELOC_ONLY:
3565       BFD_ASSERT (h->tls_type == GOT_NORMAL);
3566
3567       if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3568         hsd->low = (struct elf_link_hash_entry *) h;
3569       h->root.dynindx = hsd->max_unref_got_dynindx++;
3570       break;
3571     }
3572
3573   return TRUE;
3574 }
3575
3576 /* If H is a symbol that needs a global GOT entry, but has a dynamic
3577    symbol table index lower than any we've seen to date, record it for
3578    posterity.  FOR_CALL is true if the caller is only interested in
3579    using the GOT entry for calls.  */
3580
3581 static bfd_boolean
3582 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3583                                    bfd *abfd, struct bfd_link_info *info,
3584                                    bfd_boolean for_call,
3585                                    unsigned char tls_flag)
3586 {
3587   struct mips_elf_link_hash_table *htab;
3588   struct mips_elf_link_hash_entry *hmips;
3589   struct mips_got_entry entry, **loc;
3590   struct mips_got_info *g;
3591
3592   htab = mips_elf_hash_table (info);
3593   BFD_ASSERT (htab != NULL);
3594
3595   hmips = (struct mips_elf_link_hash_entry *) h;
3596   if (!for_call)
3597     hmips->got_only_for_calls = FALSE;
3598
3599   /* A global symbol in the GOT must also be in the dynamic symbol
3600      table.  */
3601   if (h->dynindx == -1)
3602     {
3603       switch (ELF_ST_VISIBILITY (h->other))
3604         {
3605         case STV_INTERNAL:
3606         case STV_HIDDEN:
3607           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3608           break;
3609         }
3610       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3611         return FALSE;
3612     }
3613
3614   /* Make sure we have a GOT to put this entry into.  */
3615   g = htab->got_info;
3616   BFD_ASSERT (g != NULL);
3617
3618   entry.abfd = abfd;
3619   entry.symndx = -1;
3620   entry.d.h = (struct mips_elf_link_hash_entry *) h;
3621   entry.tls_type = 0;
3622
3623   loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3624                                                    INSERT);
3625
3626   /* If we've already marked this entry as needing GOT space, we don't
3627      need to do it again.  */
3628   if (*loc)
3629     {
3630       (*loc)->tls_type |= tls_flag;
3631       return TRUE;
3632     }
3633
3634   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3635
3636   if (! *loc)
3637     return FALSE;
3638
3639   entry.gotidx = -1;
3640   entry.tls_type = tls_flag;
3641
3642   memcpy (*loc, &entry, sizeof entry);
3643
3644   if (tls_flag == 0)
3645     hmips->global_got_area = GGA_NORMAL;
3646
3647   return TRUE;
3648 }
3649
3650 /* Reserve space in G for a GOT entry containing the value of symbol
3651    SYMNDX in input bfd ABDF, plus ADDEND.  */
3652
3653 static bfd_boolean
3654 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
3655                                   struct bfd_link_info *info,
3656                                   unsigned char tls_flag)
3657 {
3658   struct mips_elf_link_hash_table *htab;
3659   struct mips_got_info *g;
3660   struct mips_got_entry entry, **loc;
3661
3662   htab = mips_elf_hash_table (info);
3663   BFD_ASSERT (htab != NULL);
3664
3665   g = htab->got_info;
3666   BFD_ASSERT (g != NULL);
3667
3668   entry.abfd = abfd;
3669   entry.symndx = symndx;
3670   entry.d.addend = addend;
3671   entry.tls_type = tls_flag;
3672   loc = (struct mips_got_entry **)
3673     htab_find_slot (g->got_entries, &entry, INSERT);
3674
3675   if (*loc)
3676     {
3677       if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
3678         {
3679           g->tls_gotno += 2;
3680           (*loc)->tls_type |= tls_flag;
3681         }
3682       else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
3683         {
3684           g->tls_gotno += 1;
3685           (*loc)->tls_type |= tls_flag;
3686         }
3687       return TRUE;
3688     }
3689
3690   if (tls_flag != 0)
3691     {
3692       entry.gotidx = -1;
3693       entry.tls_type = tls_flag;
3694       if (tls_flag == GOT_TLS_IE)
3695         g->tls_gotno += 1;
3696       else if (tls_flag == GOT_TLS_GD)
3697         g->tls_gotno += 2;
3698       else if (g->tls_ldm_offset == MINUS_ONE)
3699         {
3700           g->tls_ldm_offset = MINUS_TWO;
3701           g->tls_gotno += 2;
3702         }
3703     }
3704   else
3705     {
3706       entry.gotidx = g->local_gotno++;
3707       entry.tls_type = 0;
3708     }
3709
3710   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3711
3712   if (! *loc)
3713     return FALSE;
3714
3715   memcpy (*loc, &entry, sizeof entry);
3716
3717   return TRUE;
3718 }
3719
3720 /* Return the maximum number of GOT page entries required for RANGE.  */
3721
3722 static bfd_vma
3723 mips_elf_pages_for_range (const struct mips_got_page_range *range)
3724 {
3725   return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3726 }
3727
3728 /* Record that ABFD has a page relocation against symbol SYMNDX and
3729    that ADDEND is the addend for that relocation.
3730
3731    This function creates an upper bound on the number of GOT slots
3732    required; no attempt is made to combine references to non-overridable
3733    global symbols across multiple input files.  */
3734
3735 static bfd_boolean
3736 mips_elf_record_got_page_entry (struct bfd_link_info *info, bfd *abfd,
3737                                 long symndx, bfd_signed_vma addend)
3738 {
3739   struct mips_elf_link_hash_table *htab;
3740   struct mips_got_info *g;
3741   struct mips_got_page_entry lookup, *entry;
3742   struct mips_got_page_range **range_ptr, *range;
3743   bfd_vma old_pages, new_pages;
3744   void **loc;
3745
3746   htab = mips_elf_hash_table (info);
3747   BFD_ASSERT (htab != NULL);
3748
3749   g = htab->got_info;
3750   BFD_ASSERT (g != NULL);
3751
3752   /* Find the mips_got_page_entry hash table entry for this symbol.  */
3753   lookup.abfd = abfd;
3754   lookup.symndx = symndx;
3755   loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3756   if (loc == NULL)
3757     return FALSE;
3758
3759   /* Create a mips_got_page_entry if this is the first time we've
3760      seen the symbol.  */
3761   entry = (struct mips_got_page_entry *) *loc;
3762   if (!entry)
3763     {
3764       entry = bfd_alloc (abfd, sizeof (*entry));
3765       if (!entry)
3766         return FALSE;
3767
3768       entry->abfd = abfd;
3769       entry->symndx = symndx;
3770       entry->ranges = NULL;
3771       entry->num_pages = 0;
3772       *loc = entry;
3773     }
3774
3775   /* Skip over ranges whose maximum extent cannot share a page entry
3776      with ADDEND.  */
3777   range_ptr = &entry->ranges;
3778   while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3779     range_ptr = &(*range_ptr)->next;
3780
3781   /* If we scanned to the end of the list, or found a range whose
3782      minimum extent cannot share a page entry with ADDEND, create
3783      a new singleton range.  */
3784   range = *range_ptr;
3785   if (!range || addend < range->min_addend - 0xffff)
3786     {
3787       range = bfd_alloc (abfd, sizeof (*range));
3788       if (!range)
3789         return FALSE;
3790
3791       range->next = *range_ptr;
3792       range->min_addend = addend;
3793       range->max_addend = addend;
3794
3795       *range_ptr = range;
3796       entry->num_pages++;
3797       g->page_gotno++;
3798       return TRUE;
3799     }
3800
3801   /* Remember how many pages the old range contributed.  */
3802   old_pages = mips_elf_pages_for_range (range);
3803
3804   /* Update the ranges.  */
3805   if (addend < range->min_addend)
3806     range->min_addend = addend;
3807   else if (addend > range->max_addend)
3808     {
3809       if (range->next && addend >= range->next->min_addend - 0xffff)
3810         {
3811           old_pages += mips_elf_pages_for_range (range->next);
3812           range->max_addend = range->next->max_addend;
3813           range->next = range->next->next;
3814         }
3815       else
3816         range->max_addend = addend;
3817     }
3818
3819   /* Record any change in the total estimate.  */
3820   new_pages = mips_elf_pages_for_range (range);
3821   if (old_pages != new_pages)
3822     {
3823       entry->num_pages += new_pages - old_pages;
3824       g->page_gotno += new_pages - old_pages;
3825     }
3826
3827   return TRUE;
3828 }
3829
3830 /* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
3831
3832 static void
3833 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
3834                                        unsigned int n)
3835 {
3836   asection *s;
3837   struct mips_elf_link_hash_table *htab;
3838
3839   htab = mips_elf_hash_table (info);
3840   BFD_ASSERT (htab != NULL);
3841
3842   s = mips_elf_rel_dyn_section (info, FALSE);
3843   BFD_ASSERT (s != NULL);
3844
3845   if (htab->is_vxworks)
3846     s->size += n * MIPS_ELF_RELA_SIZE (abfd);
3847   else
3848     {
3849       if (s->size == 0)
3850         {
3851           /* Make room for a null element.  */
3852           s->size += MIPS_ELF_REL_SIZE (abfd);
3853           ++s->reloc_count;
3854         }
3855       s->size += n * MIPS_ELF_REL_SIZE (abfd);
3856     }
3857 }
3858 \f
3859 /* A htab_traverse callback for GOT entries.  Set boolean *DATA to true
3860    if the GOT entry is for an indirect or warning symbol.  */
3861
3862 static int
3863 mips_elf_check_recreate_got (void **entryp, void *data)
3864 {
3865   struct mips_got_entry *entry;
3866   bfd_boolean *must_recreate;
3867
3868   entry = (struct mips_got_entry *) *entryp;
3869   must_recreate = (bfd_boolean *) data;
3870   if (entry->abfd != NULL && entry->symndx == -1)
3871     {
3872       struct mips_elf_link_hash_entry *h;
3873
3874       h = entry->d.h;
3875       if (h->root.root.type == bfd_link_hash_indirect
3876           || h->root.root.type == bfd_link_hash_warning)
3877         {
3878           *must_recreate = TRUE;
3879           return 0;
3880         }
3881     }
3882   return 1;
3883 }
3884
3885 /* A htab_traverse callback for GOT entries.  Add all entries to
3886    hash table *DATA, converting entries for indirect and warning
3887    symbols into entries for the target symbol.  Set *DATA to null
3888    on error.  */
3889
3890 static int
3891 mips_elf_recreate_got (void **entryp, void *data)
3892 {
3893   htab_t *new_got;
3894   struct mips_got_entry *entry;
3895   void **slot;
3896
3897   new_got = (htab_t *) data;
3898   entry = (struct mips_got_entry *) *entryp;
3899   if (entry->abfd != NULL && entry->symndx == -1)
3900     {
3901       struct mips_elf_link_hash_entry *h;
3902
3903       h = entry->d.h;
3904       while (h->root.root.type == bfd_link_hash_indirect
3905              || h->root.root.type == bfd_link_hash_warning)
3906         {
3907           BFD_ASSERT (h->global_got_area == GGA_NONE);
3908           h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3909         }
3910       entry->d.h = h;
3911     }
3912   slot = htab_find_slot (*new_got, entry, INSERT);
3913   if (slot == NULL)
3914     {
3915       *new_got = NULL;
3916       return 0;
3917     }
3918   if (*slot == NULL)
3919     *slot = entry;
3920   else
3921     free (entry);
3922   return 1;
3923 }
3924
3925 /* If any entries in G->got_entries are for indirect or warning symbols,
3926    replace them with entries for the target symbol.  */
3927
3928 static bfd_boolean
3929 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3930 {
3931   bfd_boolean must_recreate;
3932   htab_t new_got;
3933
3934   must_recreate = FALSE;
3935   htab_traverse (g->got_entries, mips_elf_check_recreate_got, &must_recreate);
3936   if (must_recreate)
3937     {
3938       new_got = htab_create (htab_size (g->got_entries),
3939                              mips_elf_got_entry_hash,
3940                              mips_elf_got_entry_eq, NULL);
3941       htab_traverse (g->got_entries, mips_elf_recreate_got, &new_got);
3942       if (new_got == NULL)
3943         return FALSE;
3944
3945       /* Each entry in g->got_entries has either been copied to new_got
3946          or freed.  Now delete the hash table itself.  */
3947       htab_delete (g->got_entries);
3948       g->got_entries = new_got;
3949     }
3950   return TRUE;
3951 }
3952
3953 /* A mips_elf_link_hash_traverse callback for which DATA points
3954    to the link_info structure.  Count the number of type (3) entries
3955    in the master GOT.  */
3956
3957 static int
3958 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
3959 {
3960   struct bfd_link_info *info;
3961   struct mips_elf_link_hash_table *htab;
3962   struct mips_got_info *g;
3963
3964   info = (struct bfd_link_info *) data;
3965   htab = mips_elf_hash_table (info);
3966   g = htab->got_info;
3967   if (h->global_got_area != GGA_NONE)
3968     {
3969       /* Make a final decision about whether the symbol belongs in the
3970          local or global GOT.  Symbols that bind locally can (and in the
3971          case of forced-local symbols, must) live in the local GOT.
3972          Those that are aren't in the dynamic symbol table must also
3973          live in the local GOT.
3974
3975          Note that the former condition does not always imply the
3976          latter: symbols do not bind locally if they are completely
3977          undefined.  We'll report undefined symbols later if appropriate.  */
3978       if (h->root.dynindx == -1
3979           || (h->got_only_for_calls
3980               ? SYMBOL_CALLS_LOCAL (info, &h->root)
3981               : SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3982         {
3983           /* The symbol belongs in the local GOT.  We no longer need this
3984              entry if it was only used for relocations; those relocations
3985              will be against the null or section symbol instead of H.  */
3986           if (h->global_got_area != GGA_RELOC_ONLY)
3987             g->local_gotno++;
3988           h->global_got_area = GGA_NONE;
3989         }
3990       else if (htab->is_vxworks
3991                && h->got_only_for_calls
3992                && h->root.plt.offset != MINUS_ONE)
3993         /* On VxWorks, calls can refer directly to the .got.plt entry;
3994            they don't need entries in the regular GOT.  .got.plt entries
3995            will be allocated by _bfd_mips_elf_adjust_dynamic_symbol.  */
3996         h->global_got_area = GGA_NONE;
3997       else
3998         {
3999           g->global_gotno++;
4000           if (h->global_got_area == GGA_RELOC_ONLY)
4001             g->reloc_only_gotno++;
4002         }
4003     }
4004   return 1;
4005 }
4006 \f
4007 /* Compute the hash value of the bfd in a bfd2got hash entry.  */
4008
4009 static hashval_t
4010 mips_elf_bfd2got_entry_hash (const void *entry_)
4011 {
4012   const struct mips_elf_bfd2got_hash *entry
4013     = (struct mips_elf_bfd2got_hash *)entry_;
4014
4015   return entry->bfd->id;
4016 }
4017
4018 /* Check whether two hash entries have the same bfd.  */
4019
4020 static int
4021 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
4022 {
4023   const struct mips_elf_bfd2got_hash *e1
4024     = (const struct mips_elf_bfd2got_hash *)entry1;
4025   const struct mips_elf_bfd2got_hash *e2
4026     = (const struct mips_elf_bfd2got_hash *)entry2;
4027
4028   return e1->bfd == e2->bfd;
4029 }
4030
4031 /* In a multi-got link, determine the GOT to be used for IBFD.  G must
4032    be the master GOT data.  */
4033
4034 static struct mips_got_info *
4035 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
4036 {
4037   struct mips_elf_bfd2got_hash e, *p;
4038
4039   if (! g->bfd2got)
4040     return g;
4041
4042   e.bfd = ibfd;
4043   p = htab_find (g->bfd2got, &e);
4044   return p ? p->g : NULL;
4045 }
4046
4047 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
4048    Return NULL if an error occured.  */
4049
4050 static struct mips_got_info *
4051 mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
4052                           bfd *input_bfd)
4053 {
4054   struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
4055   struct mips_got_info *g;
4056   void **bfdgotp;
4057
4058   bfdgot_entry.bfd = input_bfd;
4059   bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
4060   bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
4061
4062   if (bfdgot == NULL)
4063     {
4064       bfdgot = ((struct mips_elf_bfd2got_hash *)
4065                 bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
4066       if (bfdgot == NULL)
4067         return NULL;
4068
4069       *bfdgotp = bfdgot;
4070
4071       g = ((struct mips_got_info *)
4072            bfd_alloc (output_bfd, sizeof (struct mips_got_info)));
4073       if (g == NULL)
4074         return NULL;
4075
4076       bfdgot->bfd = input_bfd;
4077       bfdgot->g = g;
4078
4079       g->global_gotsym = NULL;
4080       g->global_gotno = 0;
4081       g->reloc_only_gotno = 0;
4082       g->local_gotno = 0;
4083       g->page_gotno = 0;
4084       g->assigned_gotno = -1;
4085       g->tls_gotno = 0;
4086       g->tls_assigned_gotno = 0;
4087       g->tls_ldm_offset = MINUS_ONE;
4088       g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
4089                                         mips_elf_multi_got_entry_eq, NULL);
4090       if (g->got_entries == NULL)
4091         return NULL;
4092
4093       g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4094                                              mips_got_page_entry_eq, NULL);
4095       if (g->got_page_entries == NULL)
4096         return NULL;
4097
4098       g->bfd2got = NULL;
4099       g->next = NULL;
4100     }
4101
4102   return bfdgot->g;
4103 }
4104
4105 /* A htab_traverse callback for the entries in the master got.
4106    Create one separate got for each bfd that has entries in the global
4107    got, such that we can tell how many local and global entries each
4108    bfd requires.  */
4109
4110 static int
4111 mips_elf_make_got_per_bfd (void **entryp, void *p)
4112 {
4113   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4114   struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4115   struct mips_got_info *g;
4116
4117   g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4118   if (g == NULL)
4119     {
4120       arg->obfd = NULL;
4121       return 0;
4122     }
4123
4124   /* Insert the GOT entry in the bfd's got entry hash table.  */
4125   entryp = htab_find_slot (g->got_entries, entry, INSERT);
4126   if (*entryp != NULL)
4127     return 1;
4128
4129   *entryp = entry;
4130
4131   if (entry->tls_type)
4132     {
4133       if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4134         g->tls_gotno += 2;
4135       if (entry->tls_type & GOT_TLS_IE)
4136         g->tls_gotno += 1;
4137     }
4138   else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
4139     ++g->local_gotno;
4140   else
4141     ++g->global_gotno;
4142
4143   return 1;
4144 }
4145
4146 /* A htab_traverse callback for the page entries in the master got.
4147    Associate each page entry with the bfd's got.  */
4148
4149 static int
4150 mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
4151 {
4152   struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
4153   struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
4154   struct mips_got_info *g;
4155
4156   g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4157   if (g == NULL)
4158     {
4159       arg->obfd = NULL;
4160       return 0;
4161     }
4162
4163   /* Insert the GOT entry in the bfd's got entry hash table.  */
4164   entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
4165   if (*entryp != NULL)
4166     return 1;
4167
4168   *entryp = entry;
4169   g->page_gotno += entry->num_pages;
4170   return 1;
4171 }
4172
4173 /* Consider merging the got described by BFD2GOT with TO, using the
4174    information given by ARG.  Return -1 if this would lead to overflow,
4175    1 if they were merged successfully, and 0 if a merge failed due to
4176    lack of memory.  (These values are chosen so that nonnegative return
4177    values can be returned by a htab_traverse callback.)  */
4178
4179 static int
4180 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
4181                          struct mips_got_info *to,
4182                          struct mips_elf_got_per_bfd_arg *arg)
4183 {
4184   struct mips_got_info *from = bfd2got->g;
4185   unsigned int estimate;
4186
4187   /* Work out how many page entries we would need for the combined GOT.  */
4188   estimate = arg->max_pages;
4189   if (estimate >= from->page_gotno + to->page_gotno)
4190     estimate = from->page_gotno + to->page_gotno;
4191
4192   /* And conservatively estimate how many local and TLS entries
4193      would be needed.  */
4194   estimate += from->local_gotno + to->local_gotno;
4195   estimate += from->tls_gotno + to->tls_gotno;
4196
4197   /* If we're merging with the primary got, we will always have
4198      the full set of global entries.  Otherwise estimate those
4199      conservatively as well.  */
4200   if (to == arg->primary)
4201     estimate += arg->global_count;
4202   else
4203     estimate += from->global_gotno + to->global_gotno;
4204
4205   /* Bail out if the combined GOT might be too big.  */
4206   if (estimate > arg->max_count)
4207     return -1;
4208
4209   /* Commit to the merge.  Record that TO is now the bfd for this got.  */
4210   bfd2got->g = to;
4211
4212   /* Transfer the bfd's got information from FROM to TO.  */
4213   htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
4214   if (arg->obfd == NULL)
4215     return 0;
4216
4217   htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
4218   if (arg->obfd == NULL)
4219     return 0;
4220
4221   /* We don't have to worry about releasing memory of the actual
4222      got entries, since they're all in the master got_entries hash
4223      table anyway.  */
4224   htab_delete (from->got_entries);
4225   htab_delete (from->got_page_entries);
4226   return 1;
4227 }
4228
4229 /* Attempt to merge gots of different input bfds.  Try to use as much
4230    as possible of the primary got, since it doesn't require explicit
4231    dynamic relocations, but don't use bfds that would reference global
4232    symbols out of the addressable range.  Failing the primary got,
4233    attempt to merge with the current got, or finish the current got
4234    and then make make the new got current.  */
4235
4236 static int
4237 mips_elf_merge_gots (void **bfd2got_, void *p)
4238 {
4239   struct mips_elf_bfd2got_hash *bfd2got
4240     = (struct mips_elf_bfd2got_hash *)*bfd2got_;
4241   struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4242   struct mips_got_info *g;
4243   unsigned int estimate;
4244   int result;
4245
4246   g = bfd2got->g;
4247
4248   /* Work out the number of page, local and TLS entries.  */
4249   estimate = arg->max_pages;
4250   if (estimate > g->page_gotno)
4251     estimate = g->page_gotno;
4252   estimate += g->local_gotno + g->tls_gotno;
4253
4254   /* We place TLS GOT entries after both locals and globals.  The globals
4255      for the primary GOT may overflow the normal GOT size limit, so be
4256      sure not to merge a GOT which requires TLS with the primary GOT in that
4257      case.  This doesn't affect non-primary GOTs.  */
4258   estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4259
4260   if (estimate <= arg->max_count)
4261     {
4262       /* If we don't have a primary GOT, use it as
4263          a starting point for the primary GOT.  */
4264       if (!arg->primary)
4265         {
4266           arg->primary = bfd2got->g;
4267           return 1;
4268         }
4269
4270       /* Try merging with the primary GOT.  */
4271       result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
4272       if (result >= 0)
4273         return result;
4274     }
4275
4276   /* If we can merge with the last-created got, do it.  */
4277   if (arg->current)
4278     {
4279       result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
4280       if (result >= 0)
4281         return result;
4282     }
4283
4284   /* Well, we couldn't merge, so create a new GOT.  Don't check if it
4285      fits; if it turns out that it doesn't, we'll get relocation
4286      overflows anyway.  */
4287   g->next = arg->current;
4288   arg->current = g;
4289
4290   return 1;
4291 }
4292
4293 /* Set the TLS GOT index for the GOT entry in ENTRYP.  ENTRYP's NEXT field
4294    is null iff there is just a single GOT.  */
4295
4296 static int
4297 mips_elf_initialize_tls_index (void **entryp, void *p)
4298 {
4299   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4300   struct mips_got_info *g = p;
4301   bfd_vma next_index;
4302   unsigned char tls_type;
4303
4304   /* We're only interested in TLS symbols.  */
4305   if (entry->tls_type == 0)
4306     return 1;
4307
4308   next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
4309
4310   if (entry->symndx == -1 && g->next == NULL)
4311     {
4312       /* A type (3) got entry in the single-GOT case.  We use the symbol's
4313          hash table entry to track its index.  */
4314       if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
4315         return 1;
4316       entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
4317       entry->d.h->tls_got_offset = next_index;
4318       tls_type = entry->d.h->tls_type;
4319     }
4320   else
4321     {
4322       if (entry->tls_type & GOT_TLS_LDM)
4323         {
4324           /* There are separate mips_got_entry objects for each input bfd
4325              that requires an LDM entry.  Make sure that all LDM entries in
4326              a GOT resolve to the same index.  */
4327           if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
4328             {
4329               entry->gotidx = g->tls_ldm_offset;
4330               return 1;
4331             }
4332           g->tls_ldm_offset = next_index;
4333         }
4334       entry->gotidx = next_index;
4335       tls_type = entry->tls_type;
4336     }
4337
4338   /* Account for the entries we've just allocated.  */
4339   if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4340     g->tls_assigned_gotno += 2;
4341   if (tls_type & GOT_TLS_IE)
4342     g->tls_assigned_gotno += 1;
4343
4344   return 1;
4345 }
4346
4347 /* If passed a NULL mips_got_info in the argument, set the marker used
4348    to tell whether a global symbol needs a got entry (in the primary
4349    got) to the given VALUE.
4350
4351    If passed a pointer G to a mips_got_info in the argument (it must
4352    not be the primary GOT), compute the offset from the beginning of
4353    the (primary) GOT section to the entry in G corresponding to the
4354    global symbol.  G's assigned_gotno must contain the index of the
4355    first available global GOT entry in G.  VALUE must contain the size
4356    of a GOT entry in bytes.  For each global GOT entry that requires a
4357    dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
4358    marked as not eligible for lazy resolution through a function
4359    stub.  */
4360 static int
4361 mips_elf_set_global_got_offset (void **entryp, void *p)
4362 {
4363   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4364   struct mips_elf_set_global_got_offset_arg *arg
4365     = (struct mips_elf_set_global_got_offset_arg *)p;
4366   struct mips_got_info *g = arg->g;
4367
4368   if (g && entry->tls_type != GOT_NORMAL)
4369     arg->needed_relocs +=
4370       mips_tls_got_relocs (arg->info, entry->tls_type,
4371                            entry->symndx == -1 ? &entry->d.h->root : NULL);
4372
4373   if (entry->abfd != NULL
4374       && entry->symndx == -1
4375       && entry->d.h->global_got_area != GGA_NONE)
4376     {
4377       if (g)
4378         {
4379           BFD_ASSERT (g->global_gotsym == NULL);
4380
4381           entry->gotidx = arg->value * (long) g->assigned_gotno++;
4382           if (arg->info->shared
4383               || (elf_hash_table (arg->info)->dynamic_sections_created
4384                   && entry->d.h->root.def_dynamic
4385                   && !entry->d.h->root.def_regular))
4386             ++arg->needed_relocs;
4387         }
4388       else
4389         entry->d.h->global_got_area = arg->value;
4390     }
4391
4392   return 1;
4393 }
4394
4395 /* A htab_traverse callback for GOT entries for which DATA is the
4396    bfd_link_info.  Forbid any global symbols from having traditional
4397    lazy-binding stubs.  */
4398
4399 static int
4400 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4401 {
4402   struct bfd_link_info *info;
4403   struct mips_elf_link_hash_table *htab;
4404   struct mips_got_entry *entry;
4405
4406   entry = (struct mips_got_entry *) *entryp;
4407   info = (struct bfd_link_info *) data;
4408   htab = mips_elf_hash_table (info);
4409   BFD_ASSERT (htab != NULL);
4410
4411   if (entry->abfd != NULL
4412       && entry->symndx == -1
4413       && entry->d.h->needs_lazy_stub)
4414     {
4415       entry->d.h->needs_lazy_stub = FALSE;
4416       htab->lazy_stub_count--;
4417     }
4418
4419   return 1;
4420 }
4421
4422 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4423    the primary GOT.  */
4424 static bfd_vma
4425 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4426 {
4427   if (g->bfd2got == NULL)
4428     return 0;
4429
4430   g = mips_elf_got_for_ibfd (g, ibfd);
4431   if (! g)
4432     return 0;
4433
4434   BFD_ASSERT (g->next);
4435
4436   g = g->next;
4437
4438   return (g->local_gotno + g->global_gotno + g->tls_gotno)
4439     * MIPS_ELF_GOT_SIZE (abfd);
4440 }
4441
4442 /* Turn a single GOT that is too big for 16-bit addressing into
4443    a sequence of GOTs, each one 16-bit addressable.  */
4444
4445 static bfd_boolean
4446 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4447                     asection *got, bfd_size_type pages)
4448 {
4449   struct mips_elf_link_hash_table *htab;
4450   struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4451   struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
4452   struct mips_got_info *g, *gg;
4453   unsigned int assign, needed_relocs;
4454   bfd *dynobj;
4455
4456   dynobj = elf_hash_table (info)->dynobj;
4457   htab = mips_elf_hash_table (info);
4458   BFD_ASSERT (htab != NULL);
4459
4460   g = htab->got_info;
4461   g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
4462                                 mips_elf_bfd2got_entry_eq, NULL);
4463   if (g->bfd2got == NULL)
4464     return FALSE;
4465
4466   got_per_bfd_arg.bfd2got = g->bfd2got;
4467   got_per_bfd_arg.obfd = abfd;
4468   got_per_bfd_arg.info = info;
4469
4470   /* Count how many GOT entries each input bfd requires, creating a
4471      map from bfd to got info while at that.  */
4472   htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
4473   if (got_per_bfd_arg.obfd == NULL)
4474     return FALSE;
4475
4476   /* Also count how many page entries each input bfd requires.  */
4477   htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
4478                  &got_per_bfd_arg);
4479   if (got_per_bfd_arg.obfd == NULL)
4480     return FALSE;
4481
4482   got_per_bfd_arg.current = NULL;
4483   got_per_bfd_arg.primary = NULL;
4484   got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4485                                 / MIPS_ELF_GOT_SIZE (abfd))
4486                                - htab->reserved_gotno);
4487   got_per_bfd_arg.max_pages = pages;
4488   /* The number of globals that will be included in the primary GOT.
4489      See the calls to mips_elf_set_global_got_offset below for more
4490      information.  */
4491   got_per_bfd_arg.global_count = g->global_gotno;
4492
4493   /* Try to merge the GOTs of input bfds together, as long as they
4494      don't seem to exceed the maximum GOT size, choosing one of them
4495      to be the primary GOT.  */
4496   htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
4497   if (got_per_bfd_arg.obfd == NULL)
4498     return FALSE;
4499
4500   /* If we do not find any suitable primary GOT, create an empty one.  */
4501   if (got_per_bfd_arg.primary == NULL)
4502     {
4503       g->next = (struct mips_got_info *)
4504         bfd_alloc (abfd, sizeof (struct mips_got_info));
4505       if (g->next == NULL)
4506         return FALSE;
4507
4508       g->next->global_gotsym = NULL;
4509       g->next->global_gotno = 0;
4510       g->next->reloc_only_gotno = 0;
4511       g->next->local_gotno = 0;
4512       g->next->page_gotno = 0;
4513       g->next->tls_gotno = 0;
4514       g->next->assigned_gotno = 0;
4515       g->next->tls_assigned_gotno = 0;
4516       g->next->tls_ldm_offset = MINUS_ONE;
4517       g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
4518                                               mips_elf_multi_got_entry_eq,
4519                                               NULL);
4520       if (g->next->got_entries == NULL)
4521         return FALSE;
4522       g->next->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4523                                                    mips_got_page_entry_eq,
4524                                                    NULL);
4525       if (g->next->got_page_entries == NULL)
4526         return FALSE;
4527       g->next->bfd2got = NULL;
4528     }
4529   else
4530     g->next = got_per_bfd_arg.primary;
4531   g->next->next = got_per_bfd_arg.current;
4532
4533   /* GG is now the master GOT, and G is the primary GOT.  */
4534   gg = g;
4535   g = g->next;
4536
4537   /* Map the output bfd to the primary got.  That's what we're going
4538      to use for bfds that use GOT16 or GOT_PAGE relocations that we
4539      didn't mark in check_relocs, and we want a quick way to find it.
4540      We can't just use gg->next because we're going to reverse the
4541      list.  */
4542   {
4543     struct mips_elf_bfd2got_hash *bfdgot;
4544     void **bfdgotp;
4545
4546     bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
4547       (abfd, sizeof (struct mips_elf_bfd2got_hash));
4548
4549     if (bfdgot == NULL)
4550       return FALSE;
4551
4552     bfdgot->bfd = abfd;
4553     bfdgot->g = g;
4554     bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
4555
4556     BFD_ASSERT (*bfdgotp == NULL);
4557     *bfdgotp = bfdgot;
4558   }
4559
4560   /* Every symbol that is referenced in a dynamic relocation must be
4561      present in the primary GOT, so arrange for them to appear after
4562      those that are actually referenced.  */
4563   gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4564   g->global_gotno = gg->global_gotno;
4565
4566   set_got_offset_arg.g = NULL;
4567   set_got_offset_arg.value = GGA_RELOC_ONLY;
4568   htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
4569                  &set_got_offset_arg);
4570   set_got_offset_arg.value = GGA_NORMAL;
4571   htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
4572                  &set_got_offset_arg);
4573
4574   /* Now go through the GOTs assigning them offset ranges.
4575      [assigned_gotno, local_gotno[ will be set to the range of local
4576      entries in each GOT.  We can then compute the end of a GOT by
4577      adding local_gotno to global_gotno.  We reverse the list and make
4578      it circular since then we'll be able to quickly compute the
4579      beginning of a GOT, by computing the end of its predecessor.  To
4580      avoid special cases for the primary GOT, while still preserving
4581      assertions that are valid for both single- and multi-got links,
4582      we arrange for the main got struct to have the right number of
4583      global entries, but set its local_gotno such that the initial
4584      offset of the primary GOT is zero.  Remember that the primary GOT
4585      will become the last item in the circular linked list, so it
4586      points back to the master GOT.  */
4587   gg->local_gotno = -g->global_gotno;
4588   gg->global_gotno = g->global_gotno;
4589   gg->tls_gotno = 0;
4590   assign = 0;
4591   gg->next = gg;
4592
4593   do
4594     {
4595       struct mips_got_info *gn;
4596
4597       assign += htab->reserved_gotno;
4598       g->assigned_gotno = assign;
4599       g->local_gotno += assign;
4600       g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4601       assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4602
4603       /* Take g out of the direct list, and push it onto the reversed
4604          list that gg points to.  g->next is guaranteed to be nonnull after
4605          this operation, as required by mips_elf_initialize_tls_index. */
4606       gn = g->next;
4607       g->next = gg->next;
4608       gg->next = g;
4609
4610       /* Set up any TLS entries.  We always place the TLS entries after
4611          all non-TLS entries.  */
4612       g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4613       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
4614
4615       /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
4616       g = gn;
4617
4618       /* Forbid global symbols in every non-primary GOT from having
4619          lazy-binding stubs.  */
4620       if (g)
4621         htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4622     }
4623   while (g);
4624
4625   got->size = (gg->next->local_gotno
4626                + gg->next->global_gotno
4627                + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
4628
4629   needed_relocs = 0;
4630   set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (abfd);
4631   set_got_offset_arg.info = info;
4632   for (g = gg->next; g && g->next != gg; g = g->next)
4633     {
4634       unsigned int save_assign;
4635
4636       /* Assign offsets to global GOT entries.  */
4637       save_assign = g->assigned_gotno;
4638       g->assigned_gotno = g->local_gotno;
4639       set_got_offset_arg.g = g;
4640       set_got_offset_arg.needed_relocs = 0;
4641       htab_traverse (g->got_entries,
4642                      mips_elf_set_global_got_offset,
4643                      &set_got_offset_arg);
4644       needed_relocs += set_got_offset_arg.needed_relocs;
4645       BFD_ASSERT (g->assigned_gotno - g->local_gotno <= g->global_gotno);
4646
4647       g->assigned_gotno = save_assign;
4648       if (info->shared)
4649         {
4650           needed_relocs += g->local_gotno - g->assigned_gotno;
4651           BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
4652                       + g->next->global_gotno
4653                       + g->next->tls_gotno
4654                       + htab->reserved_gotno);
4655         }
4656     }
4657
4658   if (needed_relocs)
4659     mips_elf_allocate_dynamic_relocations (dynobj, info,
4660                                            needed_relocs);
4661
4662   return TRUE;
4663 }
4664
4665 \f
4666 /* Returns the first relocation of type r_type found, beginning with
4667    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
4668
4669 static const Elf_Internal_Rela *
4670 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4671                           const Elf_Internal_Rela *relocation,
4672                           const Elf_Internal_Rela *relend)
4673 {
4674   unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4675
4676   while (relocation < relend)
4677     {
4678       if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4679           && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4680         return relocation;
4681
4682       ++relocation;
4683     }
4684
4685   /* We didn't find it.  */
4686   return NULL;
4687 }
4688
4689 /* Return whether an input relocation is against a local symbol.  */
4690
4691 static bfd_boolean
4692 mips_elf_local_relocation_p (bfd *input_bfd,
4693                              const Elf_Internal_Rela *relocation,
4694                              asection **local_sections)
4695 {
4696   unsigned long r_symndx;
4697   Elf_Internal_Shdr *symtab_hdr;
4698   size_t extsymoff;
4699
4700   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4701   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4702   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4703
4704   if (r_symndx < extsymoff)
4705     return TRUE;
4706   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
4707     return TRUE;
4708
4709   return FALSE;
4710 }
4711 \f
4712 /* Sign-extend VALUE, which has the indicated number of BITS.  */
4713
4714 bfd_vma
4715 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
4716 {
4717   if (value & ((bfd_vma) 1 << (bits - 1)))
4718     /* VALUE is negative.  */
4719     value |= ((bfd_vma) - 1) << bits;
4720
4721   return value;
4722 }
4723
4724 /* Return non-zero if the indicated VALUE has overflowed the maximum
4725    range expressible by a signed number with the indicated number of
4726    BITS.  */
4727
4728 static bfd_boolean
4729 mips_elf_overflow_p (bfd_vma value, int bits)
4730 {
4731   bfd_signed_vma svalue = (bfd_signed_vma) value;
4732
4733   if (svalue > (1 << (bits - 1)) - 1)
4734     /* The value is too big.  */
4735     return TRUE;
4736   else if (svalue < -(1 << (bits - 1)))
4737     /* The value is too small.  */
4738     return TRUE;
4739
4740   /* All is well.  */
4741   return FALSE;
4742 }
4743
4744 /* Calculate the %high function.  */
4745
4746 static bfd_vma
4747 mips_elf_high (bfd_vma value)
4748 {
4749   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
4750 }
4751
4752 /* Calculate the %higher function.  */
4753
4754 static bfd_vma
4755 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
4756 {
4757 #ifdef BFD64
4758   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
4759 #else
4760   abort ();
4761   return MINUS_ONE;
4762 #endif
4763 }
4764
4765 /* Calculate the %highest function.  */
4766
4767 static bfd_vma
4768 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
4769 {
4770 #ifdef BFD64
4771   return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4772 #else
4773   abort ();
4774   return MINUS_ONE;
4775 #endif
4776 }
4777 \f
4778 /* Create the .compact_rel section.  */
4779
4780 static bfd_boolean
4781 mips_elf_create_compact_rel_section
4782   (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
4783 {
4784   flagword flags;
4785   register asection *s;
4786
4787   if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
4788     {
4789       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
4790                | SEC_READONLY);
4791
4792       s = bfd_make_section_with_flags (abfd, ".compact_rel", flags);
4793       if (s == NULL
4794           || ! bfd_set_section_alignment (abfd, s,
4795                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4796         return FALSE;
4797
4798       s->size = sizeof (Elf32_External_compact_rel);
4799     }
4800
4801   return TRUE;
4802 }
4803
4804 /* Create the .got section to hold the global offset table.  */
4805
4806 static bfd_boolean
4807 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
4808 {
4809   flagword flags;
4810   register asection *s;
4811   struct elf_link_hash_entry *h;
4812   struct bfd_link_hash_entry *bh;
4813   struct mips_got_info *g;
4814   bfd_size_type amt;
4815   struct mips_elf_link_hash_table *htab;
4816
4817   htab = mips_elf_hash_table (info);
4818   BFD_ASSERT (htab != NULL);
4819
4820   /* This function may be called more than once.  */
4821   if (htab->sgot)
4822     return TRUE;
4823
4824   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4825            | SEC_LINKER_CREATED);
4826
4827   /* We have to use an alignment of 2**4 here because this is hardcoded
4828      in the function stub generation and in the linker script.  */
4829   s = bfd_make_section_with_flags (abfd, ".got", flags);
4830   if (s == NULL
4831       || ! bfd_set_section_alignment (abfd, s, 4))
4832     return FALSE;
4833   htab->sgot = s;
4834
4835   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
4836      linker script because we don't want to define the symbol if we
4837      are not creating a global offset table.  */
4838   bh = NULL;
4839   if (! (_bfd_generic_link_add_one_symbol
4840          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4841           0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4842     return FALSE;
4843
4844   h = (struct elf_link_hash_entry *) bh;
4845   h->non_elf = 0;
4846   h->def_regular = 1;
4847   h->type = STT_OBJECT;
4848   elf_hash_table (info)->hgot = h;
4849
4850   if (info->shared
4851       && ! bfd_elf_link_record_dynamic_symbol (info, h))
4852     return FALSE;
4853
4854   amt = sizeof (struct mips_got_info);
4855   g = bfd_alloc (abfd, amt);
4856   if (g == NULL)
4857     return FALSE;
4858   g->global_gotsym = NULL;
4859   g->global_gotno = 0;
4860   g->reloc_only_gotno = 0;
4861   g->tls_gotno = 0;
4862   g->local_gotno = 0;
4863   g->page_gotno = 0;
4864   g->assigned_gotno = 0;
4865   g->bfd2got = NULL;
4866   g->next = NULL;
4867   g->tls_ldm_offset = MINUS_ONE;
4868   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
4869                                     mips_elf_got_entry_eq, NULL);
4870   if (g->got_entries == NULL)
4871     return FALSE;
4872   g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4873                                          mips_got_page_entry_eq, NULL);
4874   if (g->got_page_entries == NULL)
4875     return FALSE;
4876   htab->got_info = g;
4877   mips_elf_section_data (s)->elf.this_hdr.sh_flags
4878     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4879
4880   /* We also need a .got.plt section when generating PLTs.  */
4881   s = bfd_make_section_with_flags (abfd, ".got.plt",
4882                                    SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4883                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4884   if (s == NULL)
4885     return FALSE;
4886   htab->sgotplt = s;
4887
4888   return TRUE;
4889 }
4890 \f
4891 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4892    __GOTT_INDEX__ symbols.  These symbols are only special for
4893    shared objects; they are not used in executables.  */
4894
4895 static bfd_boolean
4896 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4897 {
4898   return (mips_elf_hash_table (info)->is_vxworks
4899           && info->shared
4900           && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4901               || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4902 }
4903
4904 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4905    require an la25 stub.  See also mips_elf_local_pic_function_p,
4906    which determines whether the destination function ever requires a
4907    stub.  */
4908
4909 static bfd_boolean
4910 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type)
4911 {
4912   /* We specifically ignore branches and jumps from EF_PIC objects,
4913      where the onus is on the compiler or programmer to perform any
4914      necessary initialization of $25.  Sometimes such initialization
4915      is unnecessary; for example, -mno-shared functions do not use
4916      the incoming value of $25, and may therefore be called directly.  */
4917   if (PIC_OBJECT_P (input_bfd))
4918     return FALSE;
4919
4920   switch (r_type)
4921     {
4922     case R_MIPS_26:
4923     case R_MIPS_PC16:
4924     case R_MIPS16_26:
4925     case R_MICROMIPS_26_S1:
4926     case R_MICROMIPS_PC7_S1:
4927     case R_MICROMIPS_PC10_S1:
4928     case R_MICROMIPS_PC16_S1:
4929     case R_MICROMIPS_PC23_S2:
4930       return TRUE;
4931
4932     default:
4933       return FALSE;
4934     }
4935 }
4936 \f
4937 /* Calculate the value produced by the RELOCATION (which comes from
4938    the INPUT_BFD).  The ADDEND is the addend to use for this
4939    RELOCATION; RELOCATION->R_ADDEND is ignored.
4940
4941    The result of the relocation calculation is stored in VALUEP.
4942    On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
4943    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
4944
4945    This function returns bfd_reloc_continue if the caller need take no
4946    further action regarding this relocation, bfd_reloc_notsupported if
4947    something goes dramatically wrong, bfd_reloc_overflow if an
4948    overflow occurs, and bfd_reloc_ok to indicate success.  */
4949
4950 static bfd_reloc_status_type
4951 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4952                                asection *input_section,
4953                                struct bfd_link_info *info,
4954                                const Elf_Internal_Rela *relocation,
4955                                bfd_vma addend, reloc_howto_type *howto,
4956                                Elf_Internal_Sym *local_syms,
4957                                asection **local_sections, bfd_vma *valuep,
4958                                const char **namep,
4959                                bfd_boolean *cross_mode_jump_p,
4960                                bfd_boolean save_addend)
4961 {
4962   /* The eventual value we will return.  */
4963   bfd_vma value;
4964   /* The address of the symbol against which the relocation is
4965      occurring.  */
4966   bfd_vma symbol = 0;
4967   /* The final GP value to be used for the relocatable, executable, or
4968      shared object file being produced.  */
4969   bfd_vma gp;
4970   /* The place (section offset or address) of the storage unit being
4971      relocated.  */
4972   bfd_vma p;
4973   /* The value of GP used to create the relocatable object.  */
4974   bfd_vma gp0;
4975   /* The offset into the global offset table at which the address of
4976      the relocation entry symbol, adjusted by the addend, resides
4977      during execution.  */
4978   bfd_vma g = MINUS_ONE;
4979   /* The section in which the symbol referenced by the relocation is
4980      located.  */
4981   asection *sec = NULL;
4982   struct mips_elf_link_hash_entry *h = NULL;
4983   /* TRUE if the symbol referred to by this relocation is a local
4984      symbol.  */
4985   bfd_boolean local_p, was_local_p;
4986   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
4987   bfd_boolean gp_disp_p = FALSE;
4988   /* TRUE if the symbol referred to by this relocation is
4989      "__gnu_local_gp".  */
4990   bfd_boolean gnu_local_gp_p = FALSE;
4991   Elf_Internal_Shdr *symtab_hdr;
4992   size_t extsymoff;
4993   unsigned long r_symndx;
4994   int r_type;
4995   /* TRUE if overflow occurred during the calculation of the
4996      relocation value.  */
4997   bfd_boolean overflowed_p;
4998   /* TRUE if this relocation refers to a MIPS16 function.  */
4999   bfd_boolean target_is_16_bit_code_p = FALSE;
5000   bfd_boolean target_is_micromips_code_p = FALSE;
5001   struct mips_elf_link_hash_table *htab;
5002   bfd *dynobj;
5003
5004   dynobj = elf_hash_table (info)->dynobj;
5005   htab = mips_elf_hash_table (info);
5006   BFD_ASSERT (htab != NULL);
5007
5008   /* Parse the relocation.  */
5009   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5010   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5011   p = (input_section->output_section->vma
5012        + input_section->output_offset
5013        + relocation->r_offset);
5014
5015   /* Assume that there will be no overflow.  */
5016   overflowed_p = FALSE;
5017
5018   /* Figure out whether or not the symbol is local, and get the offset
5019      used in the array of hash table entries.  */
5020   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5021   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5022                                          local_sections);
5023   was_local_p = local_p;
5024   if (! elf_bad_symtab (input_bfd))
5025     extsymoff = symtab_hdr->sh_info;
5026   else
5027     {
5028       /* The symbol table does not follow the rule that local symbols
5029          must come before globals.  */
5030       extsymoff = 0;
5031     }
5032
5033   /* Figure out the value of the symbol.  */
5034   if (local_p)
5035     {
5036       Elf_Internal_Sym *sym;
5037
5038       sym = local_syms + r_symndx;
5039       sec = local_sections[r_symndx];
5040
5041       symbol = sec->output_section->vma + sec->output_offset;
5042       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
5043           || (sec->flags & SEC_MERGE))
5044         symbol += sym->st_value;
5045       if ((sec->flags & SEC_MERGE)
5046           && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5047         {
5048           addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5049           addend -= symbol;
5050           addend += sec->output_section->vma + sec->output_offset;
5051         }
5052
5053       /* MIPS16/microMIPS text labels should be treated as odd.  */
5054       if (ELF_ST_IS_COMPRESSED (sym->st_other))
5055         ++symbol;
5056
5057       /* Record the name of this symbol, for our caller.  */
5058       *namep = bfd_elf_string_from_elf_section (input_bfd,
5059                                                 symtab_hdr->sh_link,
5060                                                 sym->st_name);
5061       if (*namep == '\0')
5062         *namep = bfd_section_name (input_bfd, sec);
5063
5064       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5065       target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5066     }
5067   else
5068     {
5069       /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
5070
5071       /* For global symbols we look up the symbol in the hash-table.  */
5072       h = ((struct mips_elf_link_hash_entry *)
5073            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5074       /* Find the real hash-table entry for this symbol.  */
5075       while (h->root.root.type == bfd_link_hash_indirect
5076              || h->root.root.type == bfd_link_hash_warning)
5077         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5078
5079       /* Record the name of this symbol, for our caller.  */
5080       *namep = h->root.root.root.string;
5081
5082       /* See if this is the special _gp_disp symbol.  Note that such a
5083          symbol must always be a global symbol.  */
5084       if (strcmp (*namep, "_gp_disp") == 0
5085           && ! NEWABI_P (input_bfd))
5086         {
5087           /* Relocations against _gp_disp are permitted only with
5088              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
5089           if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5090             return bfd_reloc_notsupported;
5091
5092           gp_disp_p = TRUE;
5093         }
5094       /* See if this is the special _gp symbol.  Note that such a
5095          symbol must always be a global symbol.  */
5096       else if (strcmp (*namep, "__gnu_local_gp") == 0)
5097         gnu_local_gp_p = TRUE;
5098
5099
5100       /* If this symbol is defined, calculate its address.  Note that
5101          _gp_disp is a magic symbol, always implicitly defined by the
5102          linker, so it's inappropriate to check to see whether or not
5103          its defined.  */
5104       else if ((h->root.root.type == bfd_link_hash_defined
5105                 || h->root.root.type == bfd_link_hash_defweak)
5106                && h->root.root.u.def.section)
5107         {
5108           sec = h->root.root.u.def.section;
5109           if (sec->output_section)
5110             symbol = (h->root.root.u.def.value
5111                       + sec->output_section->vma
5112                       + sec->output_offset);
5113           else
5114             symbol = h->root.root.u.def.value;
5115         }
5116       else if (h->root.root.type == bfd_link_hash_undefweak)
5117         /* We allow relocations against undefined weak symbols, giving
5118            it the value zero, so that you can undefined weak functions
5119            and check to see if they exist by looking at their
5120            addresses.  */
5121         symbol = 0;
5122       else if (info->unresolved_syms_in_objects == RM_IGNORE
5123                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5124         symbol = 0;
5125       else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5126                        ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5127         {
5128           /* If this is a dynamic link, we should have created a
5129              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5130              in in _bfd_mips_elf_create_dynamic_sections.
5131              Otherwise, we should define the symbol with a value of 0.
5132              FIXME: It should probably get into the symbol table
5133              somehow as well.  */
5134           BFD_ASSERT (! info->shared);
5135           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5136           symbol = 0;
5137         }
5138       else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5139         {
5140           /* This is an optional symbol - an Irix specific extension to the
5141              ELF spec.  Ignore it for now.
5142              XXX - FIXME - there is more to the spec for OPTIONAL symbols
5143              than simply ignoring them, but we do not handle this for now.
5144              For information see the "64-bit ELF Object File Specification"
5145              which is available from here:
5146              http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
5147           symbol = 0;
5148         }
5149       else if ((*info->callbacks->undefined_symbol)
5150                (info, h->root.root.root.string, input_bfd,
5151                 input_section, relocation->r_offset,
5152                 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5153                  || ELF_ST_VISIBILITY (h->root.other)))
5154         {
5155           return bfd_reloc_undefined;
5156         }
5157       else
5158         {
5159           return bfd_reloc_notsupported;
5160         }
5161
5162       target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5163       /* If the output section is the PLT section,
5164          then the target is not microMIPS.  */
5165       target_is_micromips_code_p = (htab->splt != sec
5166                                     && ELF_ST_IS_MICROMIPS (h->root.other));
5167     }
5168
5169   /* If this is a reference to a 16-bit function with a stub, we need
5170      to redirect the relocation to the stub unless:
5171
5172      (a) the relocation is for a MIPS16 JAL;
5173
5174      (b) the relocation is for a MIPS16 PIC call, and there are no
5175          non-MIPS16 uses of the GOT slot; or
5176
5177      (c) the section allows direct references to MIPS16 functions.  */
5178   if (r_type != R_MIPS16_26
5179       && !info->relocatable
5180       && ((h != NULL
5181            && h->fn_stub != NULL
5182            && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5183           || (local_p
5184               && elf_tdata (input_bfd)->local_stubs != NULL
5185               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5186       && !section_allows_mips16_refs_p (input_section))
5187     {
5188       /* This is a 32- or 64-bit call to a 16-bit function.  We should
5189          have already noticed that we were going to need the
5190          stub.  */
5191       if (local_p)
5192         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5193       else
5194         {
5195           BFD_ASSERT (h->need_fn_stub);
5196           sec = h->fn_stub;
5197         }
5198
5199       symbol = sec->output_section->vma + sec->output_offset;
5200       /* The target is 16-bit, but the stub isn't.  */
5201       target_is_16_bit_code_p = FALSE;
5202     }
5203   /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5204      need to redirect the call to the stub.  Note that we specifically
5205      exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5206      use an indirect stub instead.  */
5207   else if (r_type == R_MIPS16_26 && !info->relocatable
5208            && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5209                || (local_p
5210                    && elf_tdata (input_bfd)->local_call_stubs != NULL
5211                    && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5212            && !target_is_16_bit_code_p)
5213     {
5214       if (local_p)
5215         sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5216       else
5217         {
5218           /* If both call_stub and call_fp_stub are defined, we can figure
5219              out which one to use by checking which one appears in the input
5220              file.  */
5221           if (h->call_stub != NULL && h->call_fp_stub != NULL)
5222             {
5223               asection *o;
5224
5225               sec = NULL;
5226               for (o = input_bfd->sections; o != NULL; o = o->next)
5227                 {
5228                   if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5229                     {
5230                       sec = h->call_fp_stub;
5231                       break;
5232                     }
5233                 }
5234               if (sec == NULL)
5235                 sec = h->call_stub;
5236             }
5237           else if (h->call_stub != NULL)
5238             sec = h->call_stub;
5239           else
5240             sec = h->call_fp_stub;
5241         }
5242
5243       BFD_ASSERT (sec->size > 0);
5244       symbol = sec->output_section->vma + sec->output_offset;
5245     }
5246   /* If this is a direct call to a PIC function, redirect to the
5247      non-PIC stub.  */
5248   else if (h != NULL && h->la25_stub
5249            && mips_elf_relocation_needs_la25_stub (input_bfd, r_type))
5250     symbol = (h->la25_stub->stub_section->output_section->vma
5251               + h->la25_stub->stub_section->output_offset
5252               + h->la25_stub->offset);
5253
5254   /* Make sure MIPS16 and microMIPS are not used together.  */
5255   if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
5256       || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5257    {
5258       (*_bfd_error_handler)
5259         (_("MIPS16 and microMIPS functions cannot call each other"));
5260       return bfd_reloc_notsupported;
5261    }
5262
5263   /* Calls from 16-bit code to 32-bit code and vice versa require the
5264      mode change.  However, we can ignore calls to undefined weak symbols,
5265      which should never be executed at runtime.  This exception is important
5266      because the assembly writer may have "known" that any definition of the
5267      symbol would be 16-bit code, and that direct jumps were therefore
5268      acceptable.  */
5269   *cross_mode_jump_p = (!info->relocatable
5270                         && !(h && h->root.root.type == bfd_link_hash_undefweak)
5271                         && ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
5272                             || (r_type == R_MICROMIPS_26_S1
5273                                 && !target_is_micromips_code_p)
5274                             || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
5275                                 && (target_is_16_bit_code_p
5276                                     || target_is_micromips_code_p))));
5277
5278   local_p = h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->root);
5279
5280   gp0 = _bfd_get_gp_value (input_bfd);
5281   gp = _bfd_get_gp_value (abfd);
5282   if (htab->got_info)
5283     gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5284
5285   if (gnu_local_gp_p)
5286     symbol = gp;
5287
5288   /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5289      to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP.  The addend is applied by the
5290      corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.  */
5291   if (got_page_reloc_p (r_type) && !local_p)
5292     {
5293       r_type = (micromips_reloc_p (r_type)
5294                 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5295       addend = 0;
5296     }
5297
5298   /* If we haven't already determined the GOT offset, and we're going
5299      to need it, get it now.  */
5300   switch (r_type)
5301     {
5302     case R_MIPS16_CALL16:
5303     case R_MIPS16_GOT16:
5304     case R_MIPS_CALL16:
5305     case R_MIPS_GOT16:
5306     case R_MIPS_GOT_DISP:
5307     case R_MIPS_GOT_HI16:
5308     case R_MIPS_CALL_HI16:
5309     case R_MIPS_GOT_LO16:
5310     case R_MIPS_CALL_LO16:
5311     case R_MICROMIPS_CALL16:
5312     case R_MICROMIPS_GOT16:
5313     case R_MICROMIPS_GOT_DISP:
5314     case R_MICROMIPS_GOT_HI16:
5315     case R_MICROMIPS_CALL_HI16:
5316     case R_MICROMIPS_GOT_LO16:
5317     case R_MICROMIPS_CALL_LO16:
5318     case R_MIPS_TLS_GD:
5319     case R_MIPS_TLS_GOTTPREL:
5320     case R_MIPS_TLS_LDM:
5321     case R_MICROMIPS_TLS_GD:
5322     case R_MICROMIPS_TLS_GOTTPREL:
5323     case R_MICROMIPS_TLS_LDM:
5324       /* Find the index into the GOT where this value is located.  */
5325       if (tls_ldm_reloc_p (r_type))
5326         {
5327           g = mips_elf_local_got_index (abfd, input_bfd, info,
5328                                         0, 0, NULL, r_type);
5329           if (g == MINUS_ONE)
5330             return bfd_reloc_outofrange;
5331         }
5332       else if (!local_p)
5333         {
5334           /* On VxWorks, CALL relocations should refer to the .got.plt
5335              entry, which is initialized to point at the PLT stub.  */
5336           if (htab->is_vxworks
5337               && (call_hi16_reloc_p (r_type)
5338                   || call_lo16_reloc_p (r_type)
5339                   || call16_reloc_p (r_type)))
5340             {
5341               BFD_ASSERT (addend == 0);
5342               BFD_ASSERT (h->root.needs_plt);
5343               g = mips_elf_gotplt_index (info, &h->root);
5344             }
5345           else
5346             {
5347               BFD_ASSERT (addend == 0);
5348               g = mips_elf_global_got_index (dynobj, input_bfd,
5349                                              &h->root, r_type, info);
5350               if (h->tls_type == GOT_NORMAL
5351                   && !elf_hash_table (info)->dynamic_sections_created)
5352                 /* This is a static link.  We must initialize the GOT entry.  */
5353                 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
5354             }
5355         }
5356       else if (!htab->is_vxworks
5357                && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5358         /* The calculation below does not involve "g".  */
5359         break;
5360       else
5361         {
5362           g = mips_elf_local_got_index (abfd, input_bfd, info,
5363                                         symbol + addend, r_symndx, h, r_type);
5364           if (g == MINUS_ONE)
5365             return bfd_reloc_outofrange;
5366         }
5367
5368       /* Convert GOT indices to actual offsets.  */
5369       g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5370       break;
5371     }
5372
5373   /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5374      symbols are resolved by the loader.  Add them to .rela.dyn.  */
5375   if (h != NULL && is_gott_symbol (info, &h->root))
5376     {
5377       Elf_Internal_Rela outrel;
5378       bfd_byte *loc;
5379       asection *s;
5380
5381       s = mips_elf_rel_dyn_section (info, FALSE);
5382       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5383
5384       outrel.r_offset = (input_section->output_section->vma
5385                          + input_section->output_offset
5386                          + relocation->r_offset);
5387       outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5388       outrel.r_addend = addend;
5389       bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5390
5391       /* If we've written this relocation for a readonly section,
5392          we need to set DF_TEXTREL again, so that we do not delete the
5393          DT_TEXTREL tag.  */
5394       if (MIPS_ELF_READONLY_SECTION (input_section))
5395         info->flags |= DF_TEXTREL;
5396
5397       *valuep = 0;
5398       return bfd_reloc_ok;
5399     }
5400
5401   /* Figure out what kind of relocation is being performed.  */
5402   switch (r_type)
5403     {
5404     case R_MIPS_NONE:
5405       return bfd_reloc_continue;
5406
5407     case R_MIPS_16:
5408       value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
5409       overflowed_p = mips_elf_overflow_p (value, 16);
5410       break;
5411
5412     case R_MIPS_32:
5413     case R_MIPS_REL32:
5414     case R_MIPS_64:
5415       if ((info->shared
5416            || (htab->root.dynamic_sections_created
5417                && h != NULL
5418                && h->root.def_dynamic
5419                && !h->root.def_regular
5420                && !h->has_static_relocs))
5421           && r_symndx != STN_UNDEF
5422           && (h == NULL
5423               || h->root.root.type != bfd_link_hash_undefweak
5424               || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5425           && (input_section->flags & SEC_ALLOC) != 0)
5426         {
5427           /* If we're creating a shared library, then we can't know
5428              where the symbol will end up.  So, we create a relocation
5429              record in the output, and leave the job up to the dynamic
5430              linker.  We must do the same for executable references to
5431              shared library symbols, unless we've decided to use copy
5432              relocs or PLTs instead.  */
5433           value = addend;
5434           if (!mips_elf_create_dynamic_relocation (abfd,
5435                                                    info,
5436                                                    relocation,
5437                                                    h,
5438                                                    sec,
5439                                                    symbol,
5440                                                    &value,
5441                                                    input_section))
5442             return bfd_reloc_undefined;
5443         }
5444       else
5445         {
5446           if (r_type != R_MIPS_REL32)
5447             value = symbol + addend;
5448           else
5449             value = addend;
5450         }
5451       value &= howto->dst_mask;
5452       break;
5453
5454     case R_MIPS_PC32:
5455       value = symbol + addend - p;
5456       value &= howto->dst_mask;
5457       break;
5458
5459     case R_MIPS16_26:
5460       /* The calculation for R_MIPS16_26 is just the same as for an
5461          R_MIPS_26.  It's only the storage of the relocated field into
5462          the output file that's different.  That's handled in
5463          mips_elf_perform_relocation.  So, we just fall through to the
5464          R_MIPS_26 case here.  */
5465     case R_MIPS_26:
5466     case R_MICROMIPS_26_S1:
5467       {
5468         unsigned int shift;
5469
5470         /* Make sure the target of JALX is word-aligned.  Bit 0 must be
5471            the correct ISA mode selector and bit 1 must be 0.  */
5472         if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
5473           return bfd_reloc_outofrange;
5474
5475         /* Shift is 2, unusually, for microMIPS JALX.  */
5476         shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5477
5478         if (was_local_p)
5479           value = addend | ((p + 4) & (0xfc000000 << shift));
5480         else
5481           value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5482         value = (value + symbol) >> shift;
5483         if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
5484           overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5485         value &= howto->dst_mask;
5486       }
5487       break;
5488
5489     case R_MIPS_TLS_DTPREL_HI16:
5490     case R_MICROMIPS_TLS_DTPREL_HI16:
5491       value = (mips_elf_high (addend + symbol - dtprel_base (info))
5492                & howto->dst_mask);
5493       break;
5494
5495     case R_MIPS_TLS_DTPREL_LO16:
5496     case R_MIPS_TLS_DTPREL32:
5497     case R_MIPS_TLS_DTPREL64:
5498     case R_MICROMIPS_TLS_DTPREL_LO16:
5499       value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5500       break;
5501
5502     case R_MIPS_TLS_TPREL_HI16:
5503     case R_MICROMIPS_TLS_TPREL_HI16:
5504       value = (mips_elf_high (addend + symbol - tprel_base (info))
5505                & howto->dst_mask);
5506       break;
5507
5508     case R_MIPS_TLS_TPREL_LO16:
5509     case R_MICROMIPS_TLS_TPREL_LO16:
5510       value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5511       break;
5512
5513     case R_MIPS_HI16:
5514     case R_MIPS16_HI16:
5515     case R_MICROMIPS_HI16:
5516       if (!gp_disp_p)
5517         {
5518           value = mips_elf_high (addend + symbol);
5519           value &= howto->dst_mask;
5520         }
5521       else
5522         {
5523           /* For MIPS16 ABI code we generate this sequence
5524                 0: li      $v0,%hi(_gp_disp)
5525                 4: addiupc $v1,%lo(_gp_disp)
5526                 8: sll     $v0,16
5527                12: addu    $v0,$v1
5528                14: move    $gp,$v0
5529              So the offsets of hi and lo relocs are the same, but the
5530              $pc is four higher than $t9 would be, so reduce
5531              both reloc addends by 4. */
5532           if (r_type == R_MIPS16_HI16)
5533             value = mips_elf_high (addend + gp - p - 4);
5534           /* The microMIPS .cpload sequence uses the same assembly
5535              instructions as the traditional psABI version, but the
5536              incoming $t9 has the low bit set.  */
5537           else if (r_type == R_MICROMIPS_HI16)
5538             value = mips_elf_high (addend + gp - p - 1);
5539           else
5540             value = mips_elf_high (addend + gp - p);
5541           overflowed_p = mips_elf_overflow_p (value, 16);
5542         }
5543       break;
5544
5545     case R_MIPS_LO16:
5546     case R_MIPS16_LO16:
5547     case R_MICROMIPS_LO16:
5548     case R_MICROMIPS_HI0_LO16:
5549       if (!gp_disp_p)
5550         value = (symbol + addend) & howto->dst_mask;
5551       else
5552         {
5553           /* See the comment for R_MIPS16_HI16 above for the reason
5554              for this conditional.  */
5555           if (r_type == R_MIPS16_LO16)
5556             value = addend + gp - p;
5557           else if (r_type == R_MICROMIPS_LO16
5558                    || r_type == R_MICROMIPS_HI0_LO16)
5559             value = addend + gp - p + 3;
5560           else
5561             value = addend + gp - p + 4;
5562           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5563              for overflow.  But, on, say, IRIX5, relocations against
5564              _gp_disp are normally generated from the .cpload
5565              pseudo-op.  It generates code that normally looks like
5566              this:
5567
5568                lui    $gp,%hi(_gp_disp)
5569                addiu  $gp,$gp,%lo(_gp_disp)
5570                addu   $gp,$gp,$t9
5571
5572              Here $t9 holds the address of the function being called,
5573              as required by the MIPS ELF ABI.  The R_MIPS_LO16
5574              relocation can easily overflow in this situation, but the
5575              R_MIPS_HI16 relocation will handle the overflow.
5576              Therefore, we consider this a bug in the MIPS ABI, and do
5577              not check for overflow here.  */
5578         }
5579       break;
5580
5581     case R_MIPS_LITERAL:
5582     case R_MICROMIPS_LITERAL:
5583       /* Because we don't merge literal sections, we can handle this
5584          just like R_MIPS_GPREL16.  In the long run, we should merge
5585          shared literals, and then we will need to additional work
5586          here.  */
5587
5588       /* Fall through.  */
5589
5590     case R_MIPS16_GPREL:
5591       /* The R_MIPS16_GPREL performs the same calculation as
5592          R_MIPS_GPREL16, but stores the relocated bits in a different
5593          order.  We don't need to do anything special here; the
5594          differences are handled in mips_elf_perform_relocation.  */
5595     case R_MIPS_GPREL16:
5596     case R_MICROMIPS_GPREL7_S2:
5597     case R_MICROMIPS_GPREL16:
5598       /* Only sign-extend the addend if it was extracted from the
5599          instruction.  If the addend was separate, leave it alone,
5600          otherwise we may lose significant bits.  */
5601       if (howto->partial_inplace)
5602         addend = _bfd_mips_elf_sign_extend (addend, 16);
5603       value = symbol + addend - gp;
5604       /* If the symbol was local, any earlier relocatable links will
5605          have adjusted its addend with the gp offset, so compensate
5606          for that now.  Don't do it for symbols forced local in this
5607          link, though, since they won't have had the gp offset applied
5608          to them before.  */
5609       if (was_local_p)
5610         value += gp0;
5611       overflowed_p = mips_elf_overflow_p (value, 16);
5612       break;
5613
5614     case R_MIPS16_GOT16:
5615     case R_MIPS16_CALL16:
5616     case R_MIPS_GOT16:
5617     case R_MIPS_CALL16:
5618     case R_MICROMIPS_GOT16:
5619     case R_MICROMIPS_CALL16:
5620       /* VxWorks does not have separate local and global semantics for
5621          R_MIPS*_GOT16; every relocation evaluates to "G".  */
5622       if (!htab->is_vxworks && local_p)
5623         {
5624           value = mips_elf_got16_entry (abfd, input_bfd, info,
5625                                         symbol + addend, !was_local_p);
5626           if (value == MINUS_ONE)
5627             return bfd_reloc_outofrange;
5628           value
5629             = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5630           overflowed_p = mips_elf_overflow_p (value, 16);
5631           break;
5632         }
5633
5634       /* Fall through.  */
5635
5636     case R_MIPS_TLS_GD:
5637     case R_MIPS_TLS_GOTTPREL:
5638     case R_MIPS_TLS_LDM:
5639     case R_MIPS_GOT_DISP:
5640     case R_MICROMIPS_TLS_GD:
5641     case R_MICROMIPS_TLS_GOTTPREL:
5642     case R_MICROMIPS_TLS_LDM:
5643     case R_MICROMIPS_GOT_DISP:
5644       value = g;
5645       overflowed_p = mips_elf_overflow_p (value, 16);
5646       break;
5647
5648     case R_MIPS_GPREL32:
5649       value = (addend + symbol + gp0 - gp);
5650       if (!save_addend)
5651         value &= howto->dst_mask;
5652       break;
5653
5654     case R_MIPS_PC16:
5655     case R_MIPS_GNU_REL16_S2:
5656       value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
5657       overflowed_p = mips_elf_overflow_p (value, 18);
5658       value >>= howto->rightshift;
5659       value &= howto->dst_mask;
5660       break;
5661
5662     case R_MICROMIPS_PC7_S1:
5663       value = symbol + _bfd_mips_elf_sign_extend (addend, 8) - p;
5664       overflowed_p = mips_elf_overflow_p (value, 8);
5665       value >>= howto->rightshift;
5666       value &= howto->dst_mask;
5667       break;
5668
5669     case R_MICROMIPS_PC10_S1:
5670       value = symbol + _bfd_mips_elf_sign_extend (addend, 11) - p;
5671       overflowed_p = mips_elf_overflow_p (value, 11);
5672       value >>= howto->rightshift;
5673       value &= howto->dst_mask;
5674       break;
5675
5676     case R_MICROMIPS_PC16_S1:
5677       value = symbol + _bfd_mips_elf_sign_extend (addend, 17) - p;
5678       overflowed_p = mips_elf_overflow_p (value, 17);
5679       value >>= howto->rightshift;
5680       value &= howto->dst_mask;
5681       break;
5682
5683     case R_MICROMIPS_PC23_S2:
5684       value = symbol + _bfd_mips_elf_sign_extend (addend, 25) - ((p | 3) ^ 3);
5685       overflowed_p = mips_elf_overflow_p (value, 25);
5686       value >>= howto->rightshift;
5687       value &= howto->dst_mask;
5688       break;
5689
5690     case R_MIPS_GOT_HI16:
5691     case R_MIPS_CALL_HI16:
5692     case R_MICROMIPS_GOT_HI16:
5693     case R_MICROMIPS_CALL_HI16:
5694       /* We're allowed to handle these two relocations identically.
5695          The dynamic linker is allowed to handle the CALL relocations
5696          differently by creating a lazy evaluation stub.  */
5697       value = g;
5698       value = mips_elf_high (value);
5699       value &= howto->dst_mask;
5700       break;
5701
5702     case R_MIPS_GOT_LO16:
5703     case R_MIPS_CALL_LO16:
5704     case R_MICROMIPS_GOT_LO16:
5705     case R_MICROMIPS_CALL_LO16:
5706       value = g & howto->dst_mask;
5707       break;
5708
5709     case R_MIPS_GOT_PAGE:
5710     case R_MICROMIPS_GOT_PAGE:
5711       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
5712       if (value == MINUS_ONE)
5713         return bfd_reloc_outofrange;
5714       value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5715       overflowed_p = mips_elf_overflow_p (value, 16);
5716       break;
5717
5718     case R_MIPS_GOT_OFST:
5719     case R_MICROMIPS_GOT_OFST:
5720       if (local_p)
5721         mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
5722       else
5723         value = addend;
5724       overflowed_p = mips_elf_overflow_p (value, 16);
5725       break;
5726
5727     case R_MIPS_SUB:
5728     case R_MICROMIPS_SUB:
5729       value = symbol - addend;
5730       value &= howto->dst_mask;
5731       break;
5732
5733     case R_MIPS_HIGHER:
5734     case R_MICROMIPS_HIGHER:
5735       value = mips_elf_higher (addend + symbol);
5736       value &= howto->dst_mask;
5737       break;
5738
5739     case R_MIPS_HIGHEST:
5740     case R_MICROMIPS_HIGHEST:
5741       value = mips_elf_highest (addend + symbol);
5742       value &= howto->dst_mask;
5743       break;
5744
5745     case R_MIPS_SCN_DISP:
5746     case R_MICROMIPS_SCN_DISP:
5747       value = symbol + addend - sec->output_offset;
5748       value &= howto->dst_mask;
5749       break;
5750
5751     case R_MIPS_JALR:
5752     case R_MICROMIPS_JALR:
5753       /* This relocation is only a hint.  In some cases, we optimize
5754          it into a bal instruction.  But we don't try to optimize
5755          when the symbol does not resolve locally.  */
5756       if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
5757         return bfd_reloc_continue;
5758       value = symbol + addend;
5759       break;
5760
5761     case R_MIPS_PJUMP:
5762     case R_MIPS_GNU_VTINHERIT:
5763     case R_MIPS_GNU_VTENTRY:
5764       /* We don't do anything with these at present.  */
5765       return bfd_reloc_continue;
5766
5767     default:
5768       /* An unrecognized relocation type.  */
5769       return bfd_reloc_notsupported;
5770     }
5771
5772   /* Store the VALUE for our caller.  */
5773   *valuep = value;
5774   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
5775 }
5776
5777 /* Obtain the field relocated by RELOCATION.  */
5778
5779 static bfd_vma
5780 mips_elf_obtain_contents (reloc_howto_type *howto,
5781                           const Elf_Internal_Rela *relocation,
5782                           bfd *input_bfd, bfd_byte *contents)
5783 {
5784   bfd_vma x;
5785   bfd_byte *location = contents + relocation->r_offset;
5786
5787   /* Obtain the bytes.  */
5788   x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
5789
5790   return x;
5791 }
5792
5793 /* It has been determined that the result of the RELOCATION is the
5794    VALUE.  Use HOWTO to place VALUE into the output file at the
5795    appropriate position.  The SECTION is the section to which the
5796    relocation applies.
5797    CROSS_MODE_JUMP_P is true if the relocation field
5798    is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5799
5800    Returns FALSE if anything goes wrong.  */
5801
5802 static bfd_boolean
5803 mips_elf_perform_relocation (struct bfd_link_info *info,
5804                              reloc_howto_type *howto,
5805                              const Elf_Internal_Rela *relocation,
5806                              bfd_vma value, bfd *input_bfd,
5807                              asection *input_section, bfd_byte *contents,
5808                              bfd_boolean cross_mode_jump_p)
5809 {
5810   bfd_vma x;
5811   bfd_byte *location;
5812   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5813
5814   /* Figure out where the relocation is occurring.  */
5815   location = contents + relocation->r_offset;
5816
5817   _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5818
5819   /* Obtain the current value.  */
5820   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5821
5822   /* Clear the field we are setting.  */
5823   x &= ~howto->dst_mask;
5824
5825   /* Set the field.  */
5826   x |= (value & howto->dst_mask);
5827
5828   /* If required, turn JAL into JALX.  */
5829   if (cross_mode_jump_p && jal_reloc_p (r_type))
5830     {
5831       bfd_boolean ok;
5832       bfd_vma opcode = x >> 26;
5833       bfd_vma jalx_opcode;
5834
5835       /* Check to see if the opcode is already JAL or JALX.  */
5836       if (r_type == R_MIPS16_26)
5837         {
5838           ok = ((opcode == 0x6) || (opcode == 0x7));
5839           jalx_opcode = 0x7;
5840         }
5841       else if (r_type == R_MICROMIPS_26_S1)
5842         {
5843           ok = ((opcode == 0x3d) || (opcode == 0x3c));
5844           jalx_opcode = 0x3c;
5845         }
5846       else
5847         {
5848           ok = ((opcode == 0x3) || (opcode == 0x1d));
5849           jalx_opcode = 0x1d;
5850         }
5851
5852       /* If the opcode is not JAL or JALX, there's a problem.  */
5853       if (!ok)
5854         {
5855           (*_bfd_error_handler)
5856             (_("%B: %A+0x%lx: Direct jumps between ISA modes are not allowed; consider recompiling with interlinking enabled."),
5857              input_bfd,
5858              input_section,
5859              (unsigned long) relocation->r_offset);
5860           bfd_set_error (bfd_error_bad_value);
5861           return FALSE;
5862         }
5863
5864       /* Make this the JALX opcode.  */
5865       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
5866     }
5867
5868   /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5869      range.  */
5870   if (!info->relocatable
5871       && !cross_mode_jump_p
5872       && ((JAL_TO_BAL_P (input_bfd)
5873            && r_type == R_MIPS_26
5874            && (x >> 26) == 0x3)         /* jal addr */
5875           || (JALR_TO_BAL_P (input_bfd)
5876               && r_type == R_MIPS_JALR
5877               && x == 0x0320f809)       /* jalr t9 */
5878           || (JR_TO_B_P (input_bfd)
5879               && r_type == R_MIPS_JALR
5880               && x == 0x03200008)))     /* jr t9 */
5881     {
5882       bfd_vma addr;
5883       bfd_vma dest;
5884       bfd_signed_vma off;
5885
5886       addr = (input_section->output_section->vma
5887               + input_section->output_offset
5888               + relocation->r_offset
5889               + 4);
5890       if (r_type == R_MIPS_26)
5891         dest = (value << 2) | ((addr >> 28) << 28);
5892       else
5893         dest = value;
5894       off = dest - addr;
5895       if (off <= 0x1ffff && off >= -0x20000)
5896         {
5897           if (x == 0x03200008)  /* jr t9 */
5898             x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff);   /* b addr */
5899           else
5900             x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
5901         }
5902     }
5903
5904   /* Put the value into the output.  */
5905   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
5906
5907   _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
5908                                location);
5909
5910   return TRUE;
5911 }
5912 \f
5913 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
5914    is the original relocation, which is now being transformed into a
5915    dynamic relocation.  The ADDENDP is adjusted if necessary; the
5916    caller should store the result in place of the original addend.  */
5917
5918 static bfd_boolean
5919 mips_elf_create_dynamic_relocation (bfd *output_bfd,
5920                                     struct bfd_link_info *info,
5921                                     const Elf_Internal_Rela *rel,
5922                                     struct mips_elf_link_hash_entry *h,
5923                                     asection *sec, bfd_vma symbol,
5924                                     bfd_vma *addendp, asection *input_section)
5925 {
5926   Elf_Internal_Rela outrel[3];
5927   asection *sreloc;
5928   bfd *dynobj;
5929   int r_type;
5930   long indx;
5931   bfd_boolean defined_p;
5932   struct mips_elf_link_hash_table *htab;
5933
5934   htab = mips_elf_hash_table (info);
5935   BFD_ASSERT (htab != NULL);
5936
5937   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
5938   dynobj = elf_hash_table (info)->dynobj;
5939   sreloc = mips_elf_rel_dyn_section (info, FALSE);
5940   BFD_ASSERT (sreloc != NULL);
5941   BFD_ASSERT (sreloc->contents != NULL);
5942   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
5943               < sreloc->size);
5944
5945   outrel[0].r_offset =
5946     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
5947   if (ABI_64_P (output_bfd))
5948     {
5949       outrel[1].r_offset =
5950         _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
5951       outrel[2].r_offset =
5952         _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
5953     }
5954
5955   if (outrel[0].r_offset == MINUS_ONE)
5956     /* The relocation field has been deleted.  */
5957     return TRUE;
5958
5959   if (outrel[0].r_offset == MINUS_TWO)
5960     {
5961       /* The relocation field has been converted into a relative value of
5962          some sort.  Functions like _bfd_elf_write_section_eh_frame expect
5963          the field to be fully relocated, so add in the symbol's value.  */
5964       *addendp += symbol;
5965       return TRUE;
5966     }
5967
5968   /* We must now calculate the dynamic symbol table index to use
5969      in the relocation.  */
5970   if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
5971     {
5972       BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
5973       indx = h->root.dynindx;
5974       if (SGI_COMPAT (output_bfd))
5975         defined_p = h->root.def_regular;
5976       else
5977         /* ??? glibc's ld.so just adds the final GOT entry to the
5978            relocation field.  It therefore treats relocs against
5979            defined symbols in the same way as relocs against
5980            undefined symbols.  */
5981         defined_p = FALSE;
5982     }
5983   else
5984     {
5985       if (sec != NULL && bfd_is_abs_section (sec))
5986         indx = 0;
5987       else if (sec == NULL || sec->owner == NULL)
5988         {
5989           bfd_set_error (bfd_error_bad_value);
5990           return FALSE;
5991         }
5992       else
5993         {
5994           indx = elf_section_data (sec->output_section)->dynindx;
5995           if (indx == 0)
5996             {
5997               asection *osec = htab->root.text_index_section;
5998               indx = elf_section_data (osec)->dynindx;
5999             }
6000           if (indx == 0)
6001             abort ();
6002         }
6003
6004       /* Instead of generating a relocation using the section
6005          symbol, we may as well make it a fully relative
6006          relocation.  We want to avoid generating relocations to
6007          local symbols because we used to generate them
6008          incorrectly, without adding the original symbol value,
6009          which is mandated by the ABI for section symbols.  In
6010          order to give dynamic loaders and applications time to
6011          phase out the incorrect use, we refrain from emitting
6012          section-relative relocations.  It's not like they're
6013          useful, after all.  This should be a bit more efficient
6014          as well.  */
6015       /* ??? Although this behavior is compatible with glibc's ld.so,
6016          the ABI says that relocations against STN_UNDEF should have
6017          a symbol value of 0.  Irix rld honors this, so relocations
6018          against STN_UNDEF have no effect.  */
6019       if (!SGI_COMPAT (output_bfd))
6020         indx = 0;
6021       defined_p = TRUE;
6022     }
6023
6024   /* If the relocation was previously an absolute relocation and
6025      this symbol will not be referred to by the relocation, we must
6026      adjust it by the value we give it in the dynamic symbol table.
6027      Otherwise leave the job up to the dynamic linker.  */
6028   if (defined_p && r_type != R_MIPS_REL32)
6029     *addendp += symbol;
6030
6031   if (htab->is_vxworks)
6032     /* VxWorks uses non-relative relocations for this.  */
6033     outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6034   else
6035     /* The relocation is always an REL32 relocation because we don't
6036        know where the shared library will wind up at load-time.  */
6037     outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6038                                    R_MIPS_REL32);
6039
6040   /* For strict adherence to the ABI specification, we should
6041      generate a R_MIPS_64 relocation record by itself before the
6042      _REL32/_64 record as well, such that the addend is read in as
6043      a 64-bit value (REL32 is a 32-bit relocation, after all).
6044      However, since none of the existing ELF64 MIPS dynamic
6045      loaders seems to care, we don't waste space with these
6046      artificial relocations.  If this turns out to not be true,
6047      mips_elf_allocate_dynamic_relocation() should be tweaked so
6048      as to make room for a pair of dynamic relocations per
6049      invocation if ABI_64_P, and here we should generate an
6050      additional relocation record with R_MIPS_64 by itself for a
6051      NULL symbol before this relocation record.  */
6052   outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6053                                  ABI_64_P (output_bfd)
6054                                  ? R_MIPS_64
6055                                  : R_MIPS_NONE);
6056   outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6057
6058   /* Adjust the output offset of the relocation to reference the
6059      correct location in the output file.  */
6060   outrel[0].r_offset += (input_section->output_section->vma
6061                          + input_section->output_offset);
6062   outrel[1].r_offset += (input_section->output_section->vma
6063                          + input_section->output_offset);
6064   outrel[2].r_offset += (input_section->output_section->vma
6065                          + input_section->output_offset);
6066
6067   /* Put the relocation back out.  We have to use the special
6068      relocation outputter in the 64-bit case since the 64-bit
6069      relocation format is non-standard.  */
6070   if (ABI_64_P (output_bfd))
6071     {
6072       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6073         (output_bfd, &outrel[0],
6074          (sreloc->contents
6075           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6076     }
6077   else if (htab->is_vxworks)
6078     {
6079       /* VxWorks uses RELA rather than REL dynamic relocations.  */
6080       outrel[0].r_addend = *addendp;
6081       bfd_elf32_swap_reloca_out
6082         (output_bfd, &outrel[0],
6083          (sreloc->contents
6084           + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6085     }
6086   else
6087     bfd_elf32_swap_reloc_out
6088       (output_bfd, &outrel[0],
6089        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6090
6091   /* We've now added another relocation.  */
6092   ++sreloc->reloc_count;
6093
6094   /* Make sure the output section is writable.  The dynamic linker
6095      will be writing to it.  */
6096   elf_section_data (input_section->output_section)->this_hdr.sh_flags
6097     |= SHF_WRITE;
6098
6099   /* On IRIX5, make an entry of compact relocation info.  */
6100   if (IRIX_COMPAT (output_bfd) == ict_irix5)
6101     {
6102       asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
6103       bfd_byte *cr;
6104
6105       if (scpt)
6106         {
6107           Elf32_crinfo cptrel;
6108
6109           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6110           cptrel.vaddr = (rel->r_offset
6111                           + input_section->output_section->vma
6112                           + input_section->output_offset);
6113           if (r_type == R_MIPS_REL32)
6114             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6115           else
6116             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6117           mips_elf_set_cr_dist2to (cptrel, 0);
6118           cptrel.konst = *addendp;
6119
6120           cr = (scpt->contents
6121                 + sizeof (Elf32_External_compact_rel));
6122           mips_elf_set_cr_relvaddr (cptrel, 0);
6123           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6124                                      ((Elf32_External_crinfo *) cr
6125                                       + scpt->reloc_count));
6126           ++scpt->reloc_count;
6127         }
6128     }
6129
6130   /* If we've written this relocation for a readonly section,
6131      we need to set DF_TEXTREL again, so that we do not delete the
6132      DT_TEXTREL tag.  */
6133   if (MIPS_ELF_READONLY_SECTION (input_section))
6134     info->flags |= DF_TEXTREL;
6135
6136   return TRUE;
6137 }
6138 \f
6139 /* Return the MACH for a MIPS e_flags value.  */
6140
6141 unsigned long
6142 _bfd_elf_mips_mach (flagword flags)
6143 {
6144   switch (flags & EF_MIPS_MACH)
6145     {
6146     case E_MIPS_MACH_3900:
6147       return bfd_mach_mips3900;
6148
6149     case E_MIPS_MACH_4010:
6150       return bfd_mach_mips4010;
6151
6152     case E_MIPS_MACH_4100:
6153       return bfd_mach_mips4100;
6154
6155     case E_MIPS_MACH_4111:
6156       return bfd_mach_mips4111;
6157
6158     case E_MIPS_MACH_4120:
6159       return bfd_mach_mips4120;
6160
6161     case E_MIPS_MACH_4650:
6162       return bfd_mach_mips4650;
6163
6164     case E_MIPS_MACH_5400:
6165       return bfd_mach_mips5400;
6166
6167     case E_MIPS_MACH_5500:
6168       return bfd_mach_mips5500;
6169
6170     case E_MIPS_MACH_9000:
6171       return bfd_mach_mips9000;
6172
6173     case E_MIPS_MACH_SB1:
6174       return bfd_mach_mips_sb1;
6175
6176     case E_MIPS_MACH_LS2E:
6177       return bfd_mach_mips_loongson_2e;
6178
6179     case E_MIPS_MACH_LS2F:
6180       return bfd_mach_mips_loongson_2f;
6181
6182     case E_MIPS_MACH_LS3A:
6183       return bfd_mach_mips_loongson_3a;
6184
6185     case E_MIPS_MACH_OCTEON:
6186       return bfd_mach_mips_octeon;
6187
6188     case E_MIPS_MACH_XLR:
6189       return bfd_mach_mips_xlr;
6190
6191     default:
6192       switch (flags & EF_MIPS_ARCH)
6193         {
6194         default:
6195         case E_MIPS_ARCH_1:
6196           return bfd_mach_mips3000;
6197
6198         case E_MIPS_ARCH_2:
6199           return bfd_mach_mips6000;
6200
6201         case E_MIPS_ARCH_3:
6202           return bfd_mach_mips4000;
6203
6204         case E_MIPS_ARCH_4:
6205           return bfd_mach_mips8000;
6206
6207         case E_MIPS_ARCH_5:
6208           return bfd_mach_mips5;
6209
6210         case E_MIPS_ARCH_32:
6211           return bfd_mach_mipsisa32;
6212
6213         case E_MIPS_ARCH_64:
6214           return bfd_mach_mipsisa64;
6215
6216         case E_MIPS_ARCH_32R2:
6217           return bfd_mach_mipsisa32r2;
6218
6219         case E_MIPS_ARCH_64R2:
6220           return bfd_mach_mipsisa64r2;
6221         }
6222     }
6223
6224   return 0;
6225 }
6226
6227 /* Return printable name for ABI.  */
6228
6229 static INLINE char *
6230 elf_mips_abi_name (bfd *abfd)
6231 {
6232   flagword flags;
6233
6234   flags = elf_elfheader (abfd)->e_flags;
6235   switch (flags & EF_MIPS_ABI)
6236     {
6237     case 0:
6238       if (ABI_N32_P (abfd))
6239         return "N32";
6240       else if (ABI_64_P (abfd))
6241         return "64";
6242       else
6243         return "none";
6244     case E_MIPS_ABI_O32:
6245       return "O32";
6246     case E_MIPS_ABI_O64:
6247       return "O64";
6248     case E_MIPS_ABI_EABI32:
6249       return "EABI32";
6250     case E_MIPS_ABI_EABI64:
6251       return "EABI64";
6252     default:
6253       return "unknown abi";
6254     }
6255 }
6256 \f
6257 /* MIPS ELF uses two common sections.  One is the usual one, and the
6258    other is for small objects.  All the small objects are kept
6259    together, and then referenced via the gp pointer, which yields
6260    faster assembler code.  This is what we use for the small common
6261    section.  This approach is copied from ecoff.c.  */
6262 static asection mips_elf_scom_section;
6263 static asymbol mips_elf_scom_symbol;
6264 static asymbol *mips_elf_scom_symbol_ptr;
6265
6266 /* MIPS ELF also uses an acommon section, which represents an
6267    allocated common symbol which may be overridden by a
6268    definition in a shared library.  */
6269 static asection mips_elf_acom_section;
6270 static asymbol mips_elf_acom_symbol;
6271 static asymbol *mips_elf_acom_symbol_ptr;
6272
6273 /* This is used for both the 32-bit and the 64-bit ABI.  */
6274
6275 void
6276 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6277 {
6278   elf_symbol_type *elfsym;
6279
6280   /* Handle the special MIPS section numbers that a symbol may use.  */
6281   elfsym = (elf_symbol_type *) asym;
6282   switch (elfsym->internal_elf_sym.st_shndx)
6283     {
6284     case SHN_MIPS_ACOMMON:
6285       /* This section is used in a dynamically linked executable file.
6286          It is an allocated common section.  The dynamic linker can
6287          either resolve these symbols to something in a shared
6288          library, or it can just leave them here.  For our purposes,
6289          we can consider these symbols to be in a new section.  */
6290       if (mips_elf_acom_section.name == NULL)
6291         {
6292           /* Initialize the acommon section.  */
6293           mips_elf_acom_section.name = ".acommon";
6294           mips_elf_acom_section.flags = SEC_ALLOC;
6295           mips_elf_acom_section.output_section = &mips_elf_acom_section;
6296           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6297           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6298           mips_elf_acom_symbol.name = ".acommon";
6299           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6300           mips_elf_acom_symbol.section = &mips_elf_acom_section;
6301           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6302         }
6303       asym->section = &mips_elf_acom_section;
6304       break;
6305
6306     case SHN_COMMON:
6307       /* Common symbols less than the GP size are automatically
6308          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
6309       if (asym->value > elf_gp_size (abfd)
6310           || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6311           || IRIX_COMPAT (abfd) == ict_irix6)
6312         break;
6313       /* Fall through.  */
6314     case SHN_MIPS_SCOMMON:
6315       if (mips_elf_scom_section.name == NULL)
6316         {
6317           /* Initialize the small common section.  */
6318           mips_elf_scom_section.name = ".scommon";
6319           mips_elf_scom_section.flags = SEC_IS_COMMON;
6320           mips_elf_scom_section.output_section = &mips_elf_scom_section;
6321           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6322           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6323           mips_elf_scom_symbol.name = ".scommon";
6324           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6325           mips_elf_scom_symbol.section = &mips_elf_scom_section;
6326           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6327         }
6328       asym->section = &mips_elf_scom_section;
6329       asym->value = elfsym->internal_elf_sym.st_size;
6330       break;
6331
6332     case SHN_MIPS_SUNDEFINED:
6333       asym->section = bfd_und_section_ptr;
6334       break;
6335
6336     case SHN_MIPS_TEXT:
6337       {
6338         asection *section = bfd_get_section_by_name (abfd, ".text");
6339
6340         BFD_ASSERT (SGI_COMPAT (abfd));
6341         if (section != NULL)
6342           {
6343             asym->section = section;
6344             /* MIPS_TEXT is a bit special, the address is not an offset
6345                to the base of the .text section.  So substract the section
6346                base address to make it an offset.  */
6347             asym->value -= section->vma;
6348           }
6349       }
6350       break;
6351
6352     case SHN_MIPS_DATA:
6353       {
6354         asection *section = bfd_get_section_by_name (abfd, ".data");
6355
6356         BFD_ASSERT (SGI_COMPAT (abfd));
6357         if (section != NULL)
6358           {
6359             asym->section = section;
6360             /* MIPS_DATA is a bit special, the address is not an offset
6361                to the base of the .data section.  So substract the section
6362                base address to make it an offset.  */
6363             asym->value -= section->vma;
6364           }
6365       }
6366       break;
6367     }
6368
6369   /* If this is an odd-valued function symbol, assume it's a MIPS16
6370      or microMIPS one.  */
6371   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6372       && (asym->value & 1) != 0)
6373     {
6374       asym->value--;
6375       if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
6376         elfsym->internal_elf_sym.st_other
6377           = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6378       else
6379         elfsym->internal_elf_sym.st_other
6380           = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6381     }
6382 }
6383 \f
6384 /* Implement elf_backend_eh_frame_address_size.  This differs from
6385    the default in the way it handles EABI64.
6386
6387    EABI64 was originally specified as an LP64 ABI, and that is what
6388    -mabi=eabi normally gives on a 64-bit target.  However, gcc has
6389    historically accepted the combination of -mabi=eabi and -mlong32,
6390    and this ILP32 variation has become semi-official over time.
6391    Both forms use elf32 and have pointer-sized FDE addresses.
6392
6393    If an EABI object was generated by GCC 4.0 or above, it will have
6394    an empty .gcc_compiled_longXX section, where XX is the size of longs
6395    in bits.  Unfortunately, ILP32 objects generated by earlier compilers
6396    have no special marking to distinguish them from LP64 objects.
6397
6398    We don't want users of the official LP64 ABI to be punished for the
6399    existence of the ILP32 variant, but at the same time, we don't want
6400    to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6401    We therefore take the following approach:
6402
6403       - If ABFD contains a .gcc_compiled_longXX section, use it to
6404         determine the pointer size.
6405
6406       - Otherwise check the type of the first relocation.  Assume that
6407         the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6408
6409       - Otherwise punt.
6410
6411    The second check is enough to detect LP64 objects generated by pre-4.0
6412    compilers because, in the kind of output generated by those compilers,
6413    the first relocation will be associated with either a CIE personality
6414    routine or an FDE start address.  Furthermore, the compilers never
6415    used a special (non-pointer) encoding for this ABI.
6416
6417    Checking the relocation type should also be safe because there is no
6418    reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
6419    did so.  */
6420
6421 unsigned int
6422 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6423 {
6424   if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6425     return 8;
6426   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6427     {
6428       bfd_boolean long32_p, long64_p;
6429
6430       long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6431       long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6432       if (long32_p && long64_p)
6433         return 0;
6434       if (long32_p)
6435         return 4;
6436       if (long64_p)
6437         return 8;
6438
6439       if (sec->reloc_count > 0
6440           && elf_section_data (sec)->relocs != NULL
6441           && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6442               == R_MIPS_64))
6443         return 8;
6444
6445       return 0;
6446     }
6447   return 4;
6448 }
6449 \f
6450 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6451    relocations against two unnamed section symbols to resolve to the
6452    same address.  For example, if we have code like:
6453
6454         lw      $4,%got_disp(.data)($gp)
6455         lw      $25,%got_disp(.text)($gp)
6456         jalr    $25
6457
6458    then the linker will resolve both relocations to .data and the program
6459    will jump there rather than to .text.
6460
6461    We can work around this problem by giving names to local section symbols.
6462    This is also what the MIPSpro tools do.  */
6463
6464 bfd_boolean
6465 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6466 {
6467   return SGI_COMPAT (abfd);
6468 }
6469 \f
6470 /* Work over a section just before writing it out.  This routine is
6471    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
6472    sections that need the SHF_MIPS_GPREL flag by name; there has to be
6473    a better way.  */
6474
6475 bfd_boolean
6476 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
6477 {
6478   if (hdr->sh_type == SHT_MIPS_REGINFO
6479       && hdr->sh_size > 0)
6480     {
6481       bfd_byte buf[4];
6482
6483       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6484       BFD_ASSERT (hdr->contents == NULL);
6485
6486       if (bfd_seek (abfd,
6487                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6488                     SEEK_SET) != 0)
6489         return FALSE;
6490       H_PUT_32 (abfd, elf_gp (abfd), buf);
6491       if (bfd_bwrite (buf, 4, abfd) != 4)
6492         return FALSE;
6493     }
6494
6495   if (hdr->sh_type == SHT_MIPS_OPTIONS
6496       && hdr->bfd_section != NULL
6497       && mips_elf_section_data (hdr->bfd_section) != NULL
6498       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
6499     {
6500       bfd_byte *contents, *l, *lend;
6501
6502       /* We stored the section contents in the tdata field in the
6503          set_section_contents routine.  We save the section contents
6504          so that we don't have to read them again.
6505          At this point we know that elf_gp is set, so we can look
6506          through the section contents to see if there is an
6507          ODK_REGINFO structure.  */
6508
6509       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
6510       l = contents;
6511       lend = contents + hdr->sh_size;
6512       while (l + sizeof (Elf_External_Options) <= lend)
6513         {
6514           Elf_Internal_Options intopt;
6515
6516           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6517                                         &intopt);
6518           if (intopt.size < sizeof (Elf_External_Options))
6519             {
6520               (*_bfd_error_handler)
6521                 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6522                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6523               break;
6524             }
6525           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6526             {
6527               bfd_byte buf[8];
6528
6529               if (bfd_seek (abfd,
6530                             (hdr->sh_offset
6531                              + (l - contents)
6532                              + sizeof (Elf_External_Options)
6533                              + (sizeof (Elf64_External_RegInfo) - 8)),
6534                              SEEK_SET) != 0)
6535                 return FALSE;
6536               H_PUT_64 (abfd, elf_gp (abfd), buf);
6537               if (bfd_bwrite (buf, 8, abfd) != 8)
6538                 return FALSE;
6539             }
6540           else if (intopt.kind == ODK_REGINFO)
6541             {
6542               bfd_byte buf[4];
6543
6544               if (bfd_seek (abfd,
6545                             (hdr->sh_offset
6546                              + (l - contents)
6547                              + sizeof (Elf_External_Options)
6548                              + (sizeof (Elf32_External_RegInfo) - 4)),
6549                             SEEK_SET) != 0)
6550                 return FALSE;
6551               H_PUT_32 (abfd, elf_gp (abfd), buf);
6552               if (bfd_bwrite (buf, 4, abfd) != 4)
6553                 return FALSE;
6554             }
6555           l += intopt.size;
6556         }
6557     }
6558
6559   if (hdr->bfd_section != NULL)
6560     {
6561       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6562
6563       /* .sbss is not handled specially here because the GNU/Linux
6564          prelinker can convert .sbss from NOBITS to PROGBITS and
6565          changing it back to NOBITS breaks the binary.  The entry in
6566          _bfd_mips_elf_special_sections will ensure the correct flags
6567          are set on .sbss if BFD creates it without reading it from an
6568          input file, and without special handling here the flags set
6569          on it in an input file will be followed.  */
6570       if (strcmp (name, ".sdata") == 0
6571           || strcmp (name, ".lit8") == 0
6572           || strcmp (name, ".lit4") == 0)
6573         {
6574           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
6575           hdr->sh_type = SHT_PROGBITS;
6576         }
6577       else if (strcmp (name, ".srdata") == 0)
6578         {
6579           hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
6580           hdr->sh_type = SHT_PROGBITS;
6581         }
6582       else if (strcmp (name, ".compact_rel") == 0)
6583         {
6584           hdr->sh_flags = 0;
6585           hdr->sh_type = SHT_PROGBITS;
6586         }
6587       else if (strcmp (name, ".rtproc") == 0)
6588         {
6589           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
6590             {
6591               unsigned int adjust;
6592
6593               adjust = hdr->sh_size % hdr->sh_addralign;
6594               if (adjust != 0)
6595                 hdr->sh_size += hdr->sh_addralign - adjust;
6596             }
6597         }
6598     }
6599
6600   return TRUE;
6601 }
6602
6603 /* Handle a MIPS specific section when reading an object file.  This
6604    is called when elfcode.h finds a section with an unknown type.
6605    This routine supports both the 32-bit and 64-bit ELF ABI.
6606
6607    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6608    how to.  */
6609
6610 bfd_boolean
6611 _bfd_mips_elf_section_from_shdr (bfd *abfd,
6612                                  Elf_Internal_Shdr *hdr,
6613                                  const char *name,
6614                                  int shindex)
6615 {
6616   flagword flags = 0;
6617
6618   /* There ought to be a place to keep ELF backend specific flags, but
6619      at the moment there isn't one.  We just keep track of the
6620      sections by their name, instead.  Fortunately, the ABI gives
6621      suggested names for all the MIPS specific sections, so we will
6622      probably get away with this.  */
6623   switch (hdr->sh_type)
6624     {
6625     case SHT_MIPS_LIBLIST:
6626       if (strcmp (name, ".liblist") != 0)
6627         return FALSE;
6628       break;
6629     case SHT_MIPS_MSYM:
6630       if (strcmp (name, ".msym") != 0)
6631         return FALSE;
6632       break;
6633     case SHT_MIPS_CONFLICT:
6634       if (strcmp (name, ".conflict") != 0)
6635         return FALSE;
6636       break;
6637     case SHT_MIPS_GPTAB:
6638       if (! CONST_STRNEQ (name, ".gptab."))
6639         return FALSE;
6640       break;
6641     case SHT_MIPS_UCODE:
6642       if (strcmp (name, ".ucode") != 0)
6643         return FALSE;
6644       break;
6645     case SHT_MIPS_DEBUG:
6646       if (strcmp (name, ".mdebug") != 0)
6647         return FALSE;
6648       flags = SEC_DEBUGGING;
6649       break;
6650     case SHT_MIPS_REGINFO:
6651       if (strcmp (name, ".reginfo") != 0
6652           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
6653         return FALSE;
6654       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
6655       break;
6656     case SHT_MIPS_IFACE:
6657       if (strcmp (name, ".MIPS.interfaces") != 0)
6658         return FALSE;
6659       break;
6660     case SHT_MIPS_CONTENT:
6661       if (! CONST_STRNEQ (name, ".MIPS.content"))
6662         return FALSE;
6663       break;
6664     case SHT_MIPS_OPTIONS:
6665       if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6666         return FALSE;
6667       break;
6668     case SHT_MIPS_DWARF:
6669       if (! CONST_STRNEQ (name, ".debug_")
6670           && ! CONST_STRNEQ (name, ".zdebug_"))
6671         return FALSE;
6672       break;
6673     case SHT_MIPS_SYMBOL_LIB:
6674       if (strcmp (name, ".MIPS.symlib") != 0)
6675         return FALSE;
6676       break;
6677     case SHT_MIPS_EVENTS:
6678       if (! CONST_STRNEQ (name, ".MIPS.events")
6679           && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
6680         return FALSE;
6681       break;
6682     default:
6683       break;
6684     }
6685
6686   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6687     return FALSE;
6688
6689   if (flags)
6690     {
6691       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
6692                                    (bfd_get_section_flags (abfd,
6693                                                            hdr->bfd_section)
6694                                     | flags)))
6695         return FALSE;
6696     }
6697
6698   /* FIXME: We should record sh_info for a .gptab section.  */
6699
6700   /* For a .reginfo section, set the gp value in the tdata information
6701      from the contents of this section.  We need the gp value while
6702      processing relocs, so we just get it now.  The .reginfo section
6703      is not used in the 64-bit MIPS ELF ABI.  */
6704   if (hdr->sh_type == SHT_MIPS_REGINFO)
6705     {
6706       Elf32_External_RegInfo ext;
6707       Elf32_RegInfo s;
6708
6709       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
6710                                       &ext, 0, sizeof ext))
6711         return FALSE;
6712       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
6713       elf_gp (abfd) = s.ri_gp_value;
6714     }
6715
6716   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6717      set the gp value based on what we find.  We may see both
6718      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6719      they should agree.  */
6720   if (hdr->sh_type == SHT_MIPS_OPTIONS)
6721     {
6722       bfd_byte *contents, *l, *lend;
6723
6724       contents = bfd_malloc (hdr->sh_size);
6725       if (contents == NULL)
6726         return FALSE;
6727       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
6728                                       0, hdr->sh_size))
6729         {
6730           free (contents);
6731           return FALSE;
6732         }
6733       l = contents;
6734       lend = contents + hdr->sh_size;
6735       while (l + sizeof (Elf_External_Options) <= lend)
6736         {
6737           Elf_Internal_Options intopt;
6738
6739           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6740                                         &intopt);
6741           if (intopt.size < sizeof (Elf_External_Options))
6742             {
6743               (*_bfd_error_handler)
6744                 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6745                 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6746               break;
6747             }
6748           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6749             {
6750               Elf64_Internal_RegInfo intreg;
6751
6752               bfd_mips_elf64_swap_reginfo_in
6753                 (abfd,
6754                  ((Elf64_External_RegInfo *)
6755                   (l + sizeof (Elf_External_Options))),
6756                  &intreg);
6757               elf_gp (abfd) = intreg.ri_gp_value;
6758             }
6759           else if (intopt.kind == ODK_REGINFO)
6760             {
6761               Elf32_RegInfo intreg;
6762
6763               bfd_mips_elf32_swap_reginfo_in
6764                 (abfd,
6765                  ((Elf32_External_RegInfo *)
6766                   (l + sizeof (Elf_External_Options))),
6767                  &intreg);
6768               elf_gp (abfd) = intreg.ri_gp_value;
6769             }
6770           l += intopt.size;
6771         }
6772       free (contents);
6773     }
6774
6775   return TRUE;
6776 }
6777
6778 /* Set the correct type for a MIPS ELF section.  We do this by the
6779    section name, which is a hack, but ought to work.  This routine is
6780    used by both the 32-bit and the 64-bit ABI.  */
6781
6782 bfd_boolean
6783 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
6784 {
6785   const char *name = bfd_get_section_name (abfd, sec);
6786
6787   if (strcmp (name, ".liblist") == 0)
6788     {
6789       hdr->sh_type = SHT_MIPS_LIBLIST;
6790       hdr->sh_info = sec->size / sizeof (Elf32_Lib);
6791       /* The sh_link field is set in final_write_processing.  */
6792     }
6793   else if (strcmp (name, ".conflict") == 0)
6794     hdr->sh_type = SHT_MIPS_CONFLICT;
6795   else if (CONST_STRNEQ (name, ".gptab."))
6796     {
6797       hdr->sh_type = SHT_MIPS_GPTAB;
6798       hdr->sh_entsize = sizeof (Elf32_External_gptab);
6799       /* The sh_info field is set in final_write_processing.  */
6800     }
6801   else if (strcmp (name, ".ucode") == 0)
6802     hdr->sh_type = SHT_MIPS_UCODE;
6803   else if (strcmp (name, ".mdebug") == 0)
6804     {
6805       hdr->sh_type = SHT_MIPS_DEBUG;
6806       /* In a shared object on IRIX 5.3, the .mdebug section has an
6807          entsize of 0.  FIXME: Does this matter?  */
6808       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
6809         hdr->sh_entsize = 0;
6810       else
6811         hdr->sh_entsize = 1;
6812     }
6813   else if (strcmp (name, ".reginfo") == 0)
6814     {
6815       hdr->sh_type = SHT_MIPS_REGINFO;
6816       /* In a shared object on IRIX 5.3, the .reginfo section has an
6817          entsize of 0x18.  FIXME: Does this matter?  */
6818       if (SGI_COMPAT (abfd))
6819         {
6820           if ((abfd->flags & DYNAMIC) != 0)
6821             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6822           else
6823             hdr->sh_entsize = 1;
6824         }
6825       else
6826         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6827     }
6828   else if (SGI_COMPAT (abfd)
6829            && (strcmp (name, ".hash") == 0
6830                || strcmp (name, ".dynamic") == 0
6831                || strcmp (name, ".dynstr") == 0))
6832     {
6833       if (SGI_COMPAT (abfd))
6834         hdr->sh_entsize = 0;
6835 #if 0
6836       /* This isn't how the IRIX6 linker behaves.  */
6837       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
6838 #endif
6839     }
6840   else if (strcmp (name, ".got") == 0
6841            || strcmp (name, ".srdata") == 0
6842            || strcmp (name, ".sdata") == 0
6843            || strcmp (name, ".sbss") == 0
6844            || strcmp (name, ".lit4") == 0
6845            || strcmp (name, ".lit8") == 0)
6846     hdr->sh_flags |= SHF_MIPS_GPREL;
6847   else if (strcmp (name, ".MIPS.interfaces") == 0)
6848     {
6849       hdr->sh_type = SHT_MIPS_IFACE;
6850       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6851     }
6852   else if (CONST_STRNEQ (name, ".MIPS.content"))
6853     {
6854       hdr->sh_type = SHT_MIPS_CONTENT;
6855       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6856       /* The sh_info field is set in final_write_processing.  */
6857     }
6858   else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6859     {
6860       hdr->sh_type = SHT_MIPS_OPTIONS;
6861       hdr->sh_entsize = 1;
6862       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6863     }
6864   else if (CONST_STRNEQ (name, ".debug_")
6865            || CONST_STRNEQ (name, ".zdebug_"))
6866     {
6867       hdr->sh_type = SHT_MIPS_DWARF;
6868
6869       /* Irix facilities such as libexc expect a single .debug_frame
6870          per executable, the system ones have NOSTRIP set and the linker
6871          doesn't merge sections with different flags so ...  */
6872       if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
6873         hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6874     }
6875   else if (strcmp (name, ".MIPS.symlib") == 0)
6876     {
6877       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
6878       /* The sh_link and sh_info fields are set in
6879          final_write_processing.  */
6880     }
6881   else if (CONST_STRNEQ (name, ".MIPS.events")
6882            || CONST_STRNEQ (name, ".MIPS.post_rel"))
6883     {
6884       hdr->sh_type = SHT_MIPS_EVENTS;
6885       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6886       /* The sh_link field is set in final_write_processing.  */
6887     }
6888   else if (strcmp (name, ".msym") == 0)
6889     {
6890       hdr->sh_type = SHT_MIPS_MSYM;
6891       hdr->sh_flags |= SHF_ALLOC;
6892       hdr->sh_entsize = 8;
6893     }
6894
6895   /* The generic elf_fake_sections will set up REL_HDR using the default
6896    kind of relocations.  We used to set up a second header for the
6897    non-default kind of relocations here, but only NewABI would use
6898    these, and the IRIX ld doesn't like resulting empty RELA sections.
6899    Thus we create those header only on demand now.  */
6900
6901   return TRUE;
6902 }
6903
6904 /* Given a BFD section, try to locate the corresponding ELF section
6905    index.  This is used by both the 32-bit and the 64-bit ABI.
6906    Actually, it's not clear to me that the 64-bit ABI supports these,
6907    but for non-PIC objects we will certainly want support for at least
6908    the .scommon section.  */
6909
6910 bfd_boolean
6911 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6912                                         asection *sec, int *retval)
6913 {
6914   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
6915     {
6916       *retval = SHN_MIPS_SCOMMON;
6917       return TRUE;
6918     }
6919   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
6920     {
6921       *retval = SHN_MIPS_ACOMMON;
6922       return TRUE;
6923     }
6924   return FALSE;
6925 }
6926 \f
6927 /* Hook called by the linker routine which adds symbols from an object
6928    file.  We must handle the special MIPS section numbers here.  */
6929
6930 bfd_boolean
6931 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
6932                                Elf_Internal_Sym *sym, const char **namep,
6933                                flagword *flagsp ATTRIBUTE_UNUSED,
6934                                asection **secp, bfd_vma *valp)
6935 {
6936   if (SGI_COMPAT (abfd)
6937       && (abfd->flags & DYNAMIC) != 0
6938       && strcmp (*namep, "_rld_new_interface") == 0)
6939     {
6940       /* Skip IRIX5 rld entry name.  */
6941       *namep = NULL;
6942       return TRUE;
6943     }
6944
6945   /* Shared objects may have a dynamic symbol '_gp_disp' defined as
6946      a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
6947      by setting a DT_NEEDED for the shared object.  Since _gp_disp is
6948      a magic symbol resolved by the linker, we ignore this bogus definition
6949      of _gp_disp.  New ABI objects do not suffer from this problem so this
6950      is not done for them. */
6951   if (!NEWABI_P(abfd)
6952       && (sym->st_shndx == SHN_ABS)
6953       && (strcmp (*namep, "_gp_disp") == 0))
6954     {
6955       *namep = NULL;
6956       return TRUE;
6957     }
6958
6959   switch (sym->st_shndx)
6960     {
6961     case SHN_COMMON:
6962       /* Common symbols less than the GP size are automatically
6963          treated as SHN_MIPS_SCOMMON symbols.  */
6964       if (sym->st_size > elf_gp_size (abfd)
6965           || ELF_ST_TYPE (sym->st_info) == STT_TLS
6966           || IRIX_COMPAT (abfd) == ict_irix6)
6967         break;
6968       /* Fall through.  */
6969     case SHN_MIPS_SCOMMON:
6970       *secp = bfd_make_section_old_way (abfd, ".scommon");
6971       (*secp)->flags |= SEC_IS_COMMON;
6972       *valp = sym->st_size;
6973       break;
6974
6975     case SHN_MIPS_TEXT:
6976       /* This section is used in a shared object.  */
6977       if (elf_tdata (abfd)->elf_text_section == NULL)
6978         {
6979           asymbol *elf_text_symbol;
6980           asection *elf_text_section;
6981           bfd_size_type amt = sizeof (asection);
6982
6983           elf_text_section = bfd_zalloc (abfd, amt);
6984           if (elf_text_section == NULL)
6985             return FALSE;
6986
6987           amt = sizeof (asymbol);
6988           elf_text_symbol = bfd_zalloc (abfd, amt);
6989           if (elf_text_symbol == NULL)
6990             return FALSE;
6991
6992           /* Initialize the section.  */
6993
6994           elf_tdata (abfd)->elf_text_section = elf_text_section;
6995           elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
6996
6997           elf_text_section->symbol = elf_text_symbol;
6998           elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
6999
7000           elf_text_section->name = ".text";
7001           elf_text_section->flags = SEC_NO_FLAGS;
7002           elf_text_section->output_section = NULL;
7003           elf_text_section->owner = abfd;
7004           elf_text_symbol->name = ".text";
7005           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7006           elf_text_symbol->section = elf_text_section;
7007         }
7008       /* This code used to do *secp = bfd_und_section_ptr if
7009          info->shared.  I don't know why, and that doesn't make sense,
7010          so I took it out.  */
7011       *secp = elf_tdata (abfd)->elf_text_section;
7012       break;
7013
7014     case SHN_MIPS_ACOMMON:
7015       /* Fall through. XXX Can we treat this as allocated data?  */
7016     case SHN_MIPS_DATA:
7017       /* This section is used in a shared object.  */
7018       if (elf_tdata (abfd)->elf_data_section == NULL)
7019         {
7020           asymbol *elf_data_symbol;
7021           asection *elf_data_section;
7022           bfd_size_type amt = sizeof (asection);
7023
7024           elf_data_section = bfd_zalloc (abfd, amt);
7025           if (elf_data_section == NULL)
7026             return FALSE;
7027
7028           amt = sizeof (asymbol);
7029           elf_data_symbol = bfd_zalloc (abfd, amt);
7030           if (elf_data_symbol == NULL)
7031             return FALSE;
7032
7033           /* Initialize the section.  */
7034
7035           elf_tdata (abfd)->elf_data_section = elf_data_section;
7036           elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7037
7038           elf_data_section->symbol = elf_data_symbol;
7039           elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
7040
7041           elf_data_section->name = ".data";
7042           elf_data_section->flags = SEC_NO_FLAGS;
7043           elf_data_section->output_section = NULL;
7044           elf_data_section->owner = abfd;
7045           elf_data_symbol->name = ".data";
7046           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7047           elf_data_symbol->section = elf_data_section;
7048         }
7049       /* This code used to do *secp = bfd_und_section_ptr if
7050          info->shared.  I don't know why, and that doesn't make sense,
7051          so I took it out.  */
7052       *secp = elf_tdata (abfd)->elf_data_section;
7053       break;
7054
7055     case SHN_MIPS_SUNDEFINED:
7056       *secp = bfd_und_section_ptr;
7057       break;
7058     }
7059
7060   if (SGI_COMPAT (abfd)
7061       && ! info->shared
7062       && info->output_bfd->xvec == abfd->xvec
7063       && strcmp (*namep, "__rld_obj_head") == 0)
7064     {
7065       struct elf_link_hash_entry *h;
7066       struct bfd_link_hash_entry *bh;
7067
7068       /* Mark __rld_obj_head as dynamic.  */
7069       bh = NULL;
7070       if (! (_bfd_generic_link_add_one_symbol
7071              (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7072               get_elf_backend_data (abfd)->collect, &bh)))
7073         return FALSE;
7074
7075       h = (struct elf_link_hash_entry *) bh;
7076       h->non_elf = 0;
7077       h->def_regular = 1;
7078       h->type = STT_OBJECT;
7079
7080       if (! bfd_elf_link_record_dynamic_symbol (info, h))
7081         return FALSE;
7082
7083       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7084     }
7085
7086   /* If this is a mips16 text symbol, add 1 to the value to make it
7087      odd.  This will cause something like .word SYM to come up with
7088      the right value when it is loaded into the PC.  */
7089   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7090     ++*valp;
7091
7092   return TRUE;
7093 }
7094
7095 /* This hook function is called before the linker writes out a global
7096    symbol.  We mark symbols as small common if appropriate.  This is
7097    also where we undo the increment of the value for a mips16 symbol.  */
7098
7099 int
7100 _bfd_mips_elf_link_output_symbol_hook
7101   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7102    const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7103    asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7104 {
7105   /* If we see a common symbol, which implies a relocatable link, then
7106      if a symbol was small common in an input file, mark it as small
7107      common in the output file.  */
7108   if (sym->st_shndx == SHN_COMMON
7109       && strcmp (input_sec->name, ".scommon") == 0)
7110     sym->st_shndx = SHN_MIPS_SCOMMON;
7111
7112   if (ELF_ST_IS_COMPRESSED (sym->st_other))
7113     sym->st_value &= ~1;
7114
7115   return 1;
7116 }
7117 \f
7118 /* Functions for the dynamic linker.  */
7119
7120 /* Create dynamic sections when linking against a dynamic object.  */
7121
7122 bfd_boolean
7123 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7124 {
7125   struct elf_link_hash_entry *h;
7126   struct bfd_link_hash_entry *bh;
7127   flagword flags;
7128   register asection *s;
7129   const char * const *namep;
7130   struct mips_elf_link_hash_table *htab;
7131
7132   htab = mips_elf_hash_table (info);
7133   BFD_ASSERT (htab != NULL);
7134
7135   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7136            | SEC_LINKER_CREATED | SEC_READONLY);
7137
7138   /* The psABI requires a read-only .dynamic section, but the VxWorks
7139      EABI doesn't.  */
7140   if (!htab->is_vxworks)
7141     {
7142       s = bfd_get_section_by_name (abfd, ".dynamic");
7143       if (s != NULL)
7144         {
7145           if (! bfd_set_section_flags (abfd, s, flags))
7146             return FALSE;
7147         }
7148     }
7149
7150   /* We need to create .got section.  */
7151   if (!mips_elf_create_got_section (abfd, info))
7152     return FALSE;
7153
7154   if (! mips_elf_rel_dyn_section (info, TRUE))
7155     return FALSE;
7156
7157   /* Create .stub section.  */
7158   s = bfd_make_section_with_flags (abfd,
7159                                    MIPS_ELF_STUB_SECTION_NAME (abfd),
7160                                    flags | SEC_CODE);
7161   if (s == NULL
7162       || ! bfd_set_section_alignment (abfd, s,
7163                                       MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7164     return FALSE;
7165   htab->sstubs = s;
7166
7167   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
7168       && !info->shared
7169       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
7170     {
7171       s = bfd_make_section_with_flags (abfd, ".rld_map",
7172                                        flags &~ (flagword) SEC_READONLY);
7173       if (s == NULL
7174           || ! bfd_set_section_alignment (abfd, s,
7175                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7176         return FALSE;
7177     }
7178
7179   /* On IRIX5, we adjust add some additional symbols and change the
7180      alignments of several sections.  There is no ABI documentation
7181      indicating that this is necessary on IRIX6, nor any evidence that
7182      the linker takes such action.  */
7183   if (IRIX_COMPAT (abfd) == ict_irix5)
7184     {
7185       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7186         {
7187           bh = NULL;
7188           if (! (_bfd_generic_link_add_one_symbol
7189                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7190                   NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7191             return FALSE;
7192
7193           h = (struct elf_link_hash_entry *) bh;
7194           h->non_elf = 0;
7195           h->def_regular = 1;
7196           h->type = STT_SECTION;
7197
7198           if (! bfd_elf_link_record_dynamic_symbol (info, h))
7199             return FALSE;
7200         }
7201
7202       /* We need to create a .compact_rel section.  */
7203       if (SGI_COMPAT (abfd))
7204         {
7205           if (!mips_elf_create_compact_rel_section (abfd, info))
7206             return FALSE;
7207         }
7208
7209       /* Change alignments of some sections.  */
7210       s = bfd_get_section_by_name (abfd, ".hash");
7211       if (s != NULL)
7212         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7213       s = bfd_get_section_by_name (abfd, ".dynsym");
7214       if (s != NULL)
7215         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7216       s = bfd_get_section_by_name (abfd, ".dynstr");
7217       if (s != NULL)
7218         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7219       s = bfd_get_section_by_name (abfd, ".reginfo");
7220       if (s != NULL)
7221         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7222       s = bfd_get_section_by_name (abfd, ".dynamic");
7223       if (s != NULL)
7224         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7225     }
7226
7227   if (!info->shared)
7228     {
7229       const char *name;
7230
7231       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7232       bh = NULL;
7233       if (!(_bfd_generic_link_add_one_symbol
7234             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7235              NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7236         return FALSE;
7237
7238       h = (struct elf_link_hash_entry *) bh;
7239       h->non_elf = 0;
7240       h->def_regular = 1;
7241       h->type = STT_SECTION;
7242
7243       if (! bfd_elf_link_record_dynamic_symbol (info, h))
7244         return FALSE;
7245
7246       if (! mips_elf_hash_table (info)->use_rld_obj_head)
7247         {
7248           /* __rld_map is a four byte word located in the .data section
7249              and is filled in by the rtld to contain a pointer to
7250              the _r_debug structure. Its symbol value will be set in
7251              _bfd_mips_elf_finish_dynamic_symbol.  */
7252           s = bfd_get_section_by_name (abfd, ".rld_map");
7253           BFD_ASSERT (s != NULL);
7254
7255           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7256           bh = NULL;
7257           if (!(_bfd_generic_link_add_one_symbol
7258                 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7259                  get_elf_backend_data (abfd)->collect, &bh)))
7260             return FALSE;
7261
7262           h = (struct elf_link_hash_entry *) bh;
7263           h->non_elf = 0;
7264           h->def_regular = 1;
7265           h->type = STT_OBJECT;
7266
7267           if (! bfd_elf_link_record_dynamic_symbol (info, h))
7268             return FALSE;
7269         }
7270     }
7271
7272   /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7273      Also create the _PROCEDURE_LINKAGE_TABLE symbol.  */
7274   if (!_bfd_elf_create_dynamic_sections (abfd, info))
7275     return FALSE;
7276
7277   /* Cache the sections created above.  */
7278   htab->splt = bfd_get_section_by_name (abfd, ".plt");
7279   htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
7280   if (htab->is_vxworks)
7281     {
7282       htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
7283       htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
7284     }
7285   else
7286     htab->srelplt = bfd_get_section_by_name (abfd, ".rel.plt");
7287   if (!htab->sdynbss
7288       || (htab->is_vxworks && !htab->srelbss && !info->shared)
7289       || !htab->srelplt
7290       || !htab->splt)
7291     abort ();
7292
7293   if (htab->is_vxworks)
7294     {
7295       /* Do the usual VxWorks handling.  */
7296       if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7297         return FALSE;
7298
7299       /* Work out the PLT sizes.  */
7300       if (info->shared)
7301         {
7302           htab->plt_header_size
7303             = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
7304           htab->plt_entry_size
7305             = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
7306         }
7307       else
7308         {
7309           htab->plt_header_size
7310             = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
7311           htab->plt_entry_size
7312             = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
7313         }
7314     }
7315   else if (!info->shared)
7316     {
7317       /* All variants of the plt0 entry are the same size.  */
7318       htab->plt_header_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
7319       htab->plt_entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
7320     }
7321
7322   return TRUE;
7323 }
7324 \f
7325 /* Return true if relocation REL against section SEC is a REL rather than
7326    RELA relocation.  RELOCS is the first relocation in the section and
7327    ABFD is the bfd that contains SEC.  */
7328
7329 static bfd_boolean
7330 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7331                            const Elf_Internal_Rela *relocs,
7332                            const Elf_Internal_Rela *rel)
7333 {
7334   Elf_Internal_Shdr *rel_hdr;
7335   const struct elf_backend_data *bed;
7336
7337   /* To determine which flavor of relocation this is, we depend on the
7338      fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR.  */
7339   rel_hdr = elf_section_data (sec)->rel.hdr;
7340   if (rel_hdr == NULL)
7341     return FALSE;
7342   bed = get_elf_backend_data (abfd);
7343   return ((size_t) (rel - relocs)
7344           < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7345 }
7346
7347 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7348    HOWTO is the relocation's howto and CONTENTS points to the contents
7349    of the section that REL is against.  */
7350
7351 static bfd_vma
7352 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7353                           reloc_howto_type *howto, bfd_byte *contents)
7354 {
7355   bfd_byte *location;
7356   unsigned int r_type;
7357   bfd_vma addend;
7358
7359   r_type = ELF_R_TYPE (abfd, rel->r_info);
7360   location = contents + rel->r_offset;
7361
7362   /* Get the addend, which is stored in the input file.  */
7363   _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7364   addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
7365   _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7366
7367   return addend & howto->src_mask;
7368 }
7369
7370 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7371    and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
7372    and update *ADDEND with the final addend.  Return true on success
7373    or false if the LO16 could not be found.  RELEND is the exclusive
7374    upper bound on the relocations for REL's section.  */
7375
7376 static bfd_boolean
7377 mips_elf_add_lo16_rel_addend (bfd *abfd,
7378                               const Elf_Internal_Rela *rel,
7379                               const Elf_Internal_Rela *relend,
7380                               bfd_byte *contents, bfd_vma *addend)
7381 {
7382   unsigned int r_type, lo16_type;
7383   const Elf_Internal_Rela *lo16_relocation;
7384   reloc_howto_type *lo16_howto;
7385   bfd_vma l;
7386
7387   r_type = ELF_R_TYPE (abfd, rel->r_info);
7388   if (mips16_reloc_p (r_type))
7389     lo16_type = R_MIPS16_LO16;
7390   else if (micromips_reloc_p (r_type))
7391     lo16_type = R_MICROMIPS_LO16;
7392   else
7393     lo16_type = R_MIPS_LO16;
7394
7395   /* The combined value is the sum of the HI16 addend, left-shifted by
7396      sixteen bits, and the LO16 addend, sign extended.  (Usually, the
7397      code does a `lui' of the HI16 value, and then an `addiu' of the
7398      LO16 value.)
7399
7400      Scan ahead to find a matching LO16 relocation.
7401
7402      According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7403      be immediately following.  However, for the IRIX6 ABI, the next
7404      relocation may be a composed relocation consisting of several
7405      relocations for the same address.  In that case, the R_MIPS_LO16
7406      relocation may occur as one of these.  We permit a similar
7407      extension in general, as that is useful for GCC.
7408
7409      In some cases GCC dead code elimination removes the LO16 but keeps
7410      the corresponding HI16.  This is strictly speaking a violation of
7411      the ABI but not immediately harmful.  */
7412   lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7413   if (lo16_relocation == NULL)
7414     return FALSE;
7415
7416   /* Obtain the addend kept there.  */
7417   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7418   l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7419
7420   l <<= lo16_howto->rightshift;
7421   l = _bfd_mips_elf_sign_extend (l, 16);
7422
7423   *addend <<= 16;
7424   *addend += l;
7425   return TRUE;
7426 }
7427
7428 /* Try to read the contents of section SEC in bfd ABFD.  Return true and
7429    store the contents in *CONTENTS on success.  Assume that *CONTENTS
7430    already holds the contents if it is nonull on entry.  */
7431
7432 static bfd_boolean
7433 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7434 {
7435   if (*contents)
7436     return TRUE;
7437
7438   /* Get cached copy if it exists.  */
7439   if (elf_section_data (sec)->this_hdr.contents != NULL)
7440     {
7441       *contents = elf_section_data (sec)->this_hdr.contents;
7442       return TRUE;
7443     }
7444
7445   return bfd_malloc_and_get_section (abfd, sec, contents);
7446 }
7447
7448 /* Look through the relocs for a section during the first phase, and
7449    allocate space in the global offset table.  */
7450
7451 bfd_boolean
7452 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7453                             asection *sec, const Elf_Internal_Rela *relocs)
7454 {
7455   const char *name;
7456   bfd *dynobj;
7457   Elf_Internal_Shdr *symtab_hdr;
7458   struct elf_link_hash_entry **sym_hashes;
7459   size_t extsymoff;
7460   const Elf_Internal_Rela *rel;
7461   const Elf_Internal_Rela *rel_end;
7462   asection *sreloc;
7463   const struct elf_backend_data *bed;
7464   struct mips_elf_link_hash_table *htab;
7465   bfd_byte *contents;
7466   bfd_vma addend;
7467   reloc_howto_type *howto;
7468
7469   if (info->relocatable)
7470     return TRUE;
7471
7472   htab = mips_elf_hash_table (info);
7473   BFD_ASSERT (htab != NULL);
7474
7475   dynobj = elf_hash_table (info)->dynobj;
7476   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7477   sym_hashes = elf_sym_hashes (abfd);
7478   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7479
7480   bed = get_elf_backend_data (abfd);
7481   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7482
7483   /* Check for the mips16 stub sections.  */
7484
7485   name = bfd_get_section_name (abfd, sec);
7486   if (FN_STUB_P (name))
7487     {
7488       unsigned long r_symndx;
7489
7490       /* Look at the relocation information to figure out which symbol
7491          this is for.  */
7492
7493       r_symndx = mips16_stub_symndx (sec, relocs, rel_end);
7494       if (r_symndx == 0)
7495         {
7496           (*_bfd_error_handler)
7497             (_("%B: Warning: cannot determine the target function for"
7498                " stub section `%s'"),
7499              abfd, name);
7500           bfd_set_error (bfd_error_bad_value);
7501           return FALSE;
7502         }
7503
7504       if (r_symndx < extsymoff
7505           || sym_hashes[r_symndx - extsymoff] == NULL)
7506         {
7507           asection *o;
7508
7509           /* This stub is for a local symbol.  This stub will only be
7510              needed if there is some relocation in this BFD, other
7511              than a 16 bit function call, which refers to this symbol.  */
7512           for (o = abfd->sections; o != NULL; o = o->next)
7513             {
7514               Elf_Internal_Rela *sec_relocs;
7515               const Elf_Internal_Rela *r, *rend;
7516
7517               /* We can ignore stub sections when looking for relocs.  */
7518               if ((o->flags & SEC_RELOC) == 0
7519                   || o->reloc_count == 0
7520                   || section_allows_mips16_refs_p (o))
7521                 continue;
7522
7523               sec_relocs
7524                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7525                                              info->keep_memory);
7526               if (sec_relocs == NULL)
7527                 return FALSE;
7528
7529               rend = sec_relocs + o->reloc_count;
7530               for (r = sec_relocs; r < rend; r++)
7531                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7532                     && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
7533                   break;
7534
7535               if (elf_section_data (o)->relocs != sec_relocs)
7536                 free (sec_relocs);
7537
7538               if (r < rend)
7539                 break;
7540             }
7541
7542           if (o == NULL)
7543             {
7544               /* There is no non-call reloc for this stub, so we do
7545                  not need it.  Since this function is called before
7546                  the linker maps input sections to output sections, we
7547                  can easily discard it by setting the SEC_EXCLUDE
7548                  flag.  */
7549               sec->flags |= SEC_EXCLUDE;
7550               return TRUE;
7551             }
7552
7553           /* Record this stub in an array of local symbol stubs for
7554              this BFD.  */
7555           if (elf_tdata (abfd)->local_stubs == NULL)
7556             {
7557               unsigned long symcount;
7558               asection **n;
7559               bfd_size_type amt;
7560
7561               if (elf_bad_symtab (abfd))
7562                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7563               else
7564                 symcount = symtab_hdr->sh_info;
7565               amt = symcount * sizeof (asection *);
7566               n = bfd_zalloc (abfd, amt);
7567               if (n == NULL)
7568                 return FALSE;
7569               elf_tdata (abfd)->local_stubs = n;
7570             }
7571
7572           sec->flags |= SEC_KEEP;
7573           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7574
7575           /* We don't need to set mips16_stubs_seen in this case.
7576              That flag is used to see whether we need to look through
7577              the global symbol table for stubs.  We don't need to set
7578              it here, because we just have a local stub.  */
7579         }
7580       else
7581         {
7582           struct mips_elf_link_hash_entry *h;
7583
7584           h = ((struct mips_elf_link_hash_entry *)
7585                sym_hashes[r_symndx - extsymoff]);
7586
7587           while (h->root.root.type == bfd_link_hash_indirect
7588                  || h->root.root.type == bfd_link_hash_warning)
7589             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7590
7591           /* H is the symbol this stub is for.  */
7592
7593           /* If we already have an appropriate stub for this function, we
7594              don't need another one, so we can discard this one.  Since
7595              this function is called before the linker maps input sections
7596              to output sections, we can easily discard it by setting the
7597              SEC_EXCLUDE flag.  */
7598           if (h->fn_stub != NULL)
7599             {
7600               sec->flags |= SEC_EXCLUDE;
7601               return TRUE;
7602             }
7603
7604           sec->flags |= SEC_KEEP;
7605           h->fn_stub = sec;
7606           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7607         }
7608     }
7609   else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
7610     {
7611       unsigned long r_symndx;
7612       struct mips_elf_link_hash_entry *h;
7613       asection **loc;
7614
7615       /* Look at the relocation information to figure out which symbol
7616          this is for.  */
7617
7618       r_symndx = mips16_stub_symndx (sec, relocs, rel_end);
7619       if (r_symndx == 0)
7620         {
7621           (*_bfd_error_handler)
7622             (_("%B: Warning: cannot determine the target function for"
7623                " stub section `%s'"),
7624              abfd, name);
7625           bfd_set_error (bfd_error_bad_value);
7626           return FALSE;
7627         }
7628
7629       if (r_symndx < extsymoff
7630           || sym_hashes[r_symndx - extsymoff] == NULL)
7631         {
7632           asection *o;
7633
7634           /* This stub is for a local symbol.  This stub will only be
7635              needed if there is some relocation (R_MIPS16_26) in this BFD
7636              that refers to this symbol.  */
7637           for (o = abfd->sections; o != NULL; o = o->next)
7638             {
7639               Elf_Internal_Rela *sec_relocs;
7640               const Elf_Internal_Rela *r, *rend;
7641
7642               /* We can ignore stub sections when looking for relocs.  */
7643               if ((o->flags & SEC_RELOC) == 0
7644                   || o->reloc_count == 0
7645                   || section_allows_mips16_refs_p (o))
7646                 continue;
7647
7648               sec_relocs
7649                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7650                                              info->keep_memory);
7651               if (sec_relocs == NULL)
7652                 return FALSE;
7653
7654               rend = sec_relocs + o->reloc_count;
7655               for (r = sec_relocs; r < rend; r++)
7656                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7657                     && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
7658                     break;
7659
7660               if (elf_section_data (o)->relocs != sec_relocs)
7661                 free (sec_relocs);
7662
7663               if (r < rend)
7664                 break;
7665             }
7666
7667           if (o == NULL)
7668             {
7669               /* There is no non-call reloc for this stub, so we do
7670                  not need it.  Since this function is called before
7671                  the linker maps input sections to output sections, we
7672                  can easily discard it by setting the SEC_EXCLUDE
7673                  flag.  */
7674               sec->flags |= SEC_EXCLUDE;
7675               return TRUE;
7676             }
7677
7678           /* Record this stub in an array of local symbol call_stubs for
7679              this BFD.  */
7680           if (elf_tdata (abfd)->local_call_stubs == NULL)
7681             {
7682               unsigned long symcount;
7683               asection **n;
7684               bfd_size_type amt;
7685
7686               if (elf_bad_symtab (abfd))
7687                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7688               else
7689                 symcount = symtab_hdr->sh_info;
7690               amt = symcount * sizeof (asection *);
7691               n = bfd_zalloc (abfd, amt);
7692               if (n == NULL)
7693                 return FALSE;
7694               elf_tdata (abfd)->local_call_stubs = n;
7695             }
7696
7697           sec->flags |= SEC_KEEP;
7698           elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
7699
7700           /* We don't need to set mips16_stubs_seen in this case.
7701              That flag is used to see whether we need to look through
7702              the global symbol table for stubs.  We don't need to set
7703              it here, because we just have a local stub.  */
7704         }
7705       else
7706         {
7707           h = ((struct mips_elf_link_hash_entry *)
7708                sym_hashes[r_symndx - extsymoff]);
7709
7710           /* H is the symbol this stub is for.  */
7711
7712           if (CALL_FP_STUB_P (name))
7713             loc = &h->call_fp_stub;
7714           else
7715             loc = &h->call_stub;
7716
7717           /* If we already have an appropriate stub for this function, we
7718              don't need another one, so we can discard this one.  Since
7719              this function is called before the linker maps input sections
7720              to output sections, we can easily discard it by setting the
7721              SEC_EXCLUDE flag.  */
7722           if (*loc != NULL)
7723             {
7724               sec->flags |= SEC_EXCLUDE;
7725               return TRUE;
7726             }
7727
7728           sec->flags |= SEC_KEEP;
7729           *loc = sec;
7730           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7731         }
7732     }
7733
7734   sreloc = NULL;
7735   contents = NULL;
7736   for (rel = relocs; rel < rel_end; ++rel)
7737     {
7738       unsigned long r_symndx;
7739       unsigned int r_type;
7740       struct elf_link_hash_entry *h;
7741       bfd_boolean can_make_dynamic_p;
7742
7743       r_symndx = ELF_R_SYM (abfd, rel->r_info);
7744       r_type = ELF_R_TYPE (abfd, rel->r_info);
7745
7746       if (r_symndx < extsymoff)
7747         h = NULL;
7748       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7749         {
7750           (*_bfd_error_handler)
7751             (_("%B: Malformed reloc detected for section %s"),
7752              abfd, name);
7753           bfd_set_error (bfd_error_bad_value);
7754           return FALSE;
7755         }
7756       else
7757         {
7758           h = sym_hashes[r_symndx - extsymoff];
7759           while (h != NULL
7760                  && (h->root.type == bfd_link_hash_indirect
7761                      || h->root.type == bfd_link_hash_warning))
7762             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7763         }
7764
7765       /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7766          relocation into a dynamic one.  */
7767       can_make_dynamic_p = FALSE;
7768       switch (r_type)
7769         {
7770         case R_MIPS16_GOT16:
7771         case R_MIPS16_CALL16:
7772         case R_MIPS_GOT16:
7773         case R_MIPS_CALL16:
7774         case R_MIPS_CALL_HI16:
7775         case R_MIPS_CALL_LO16:
7776         case R_MIPS_GOT_HI16:
7777         case R_MIPS_GOT_LO16:
7778         case R_MIPS_GOT_PAGE:
7779         case R_MIPS_GOT_OFST:
7780         case R_MIPS_GOT_DISP:
7781         case R_MIPS_TLS_GOTTPREL:
7782         case R_MIPS_TLS_GD:
7783         case R_MIPS_TLS_LDM:
7784         case R_MICROMIPS_GOT16:
7785         case R_MICROMIPS_CALL16:
7786         case R_MICROMIPS_CALL_HI16:
7787         case R_MICROMIPS_CALL_LO16:
7788         case R_MICROMIPS_GOT_HI16:
7789         case R_MICROMIPS_GOT_LO16:
7790         case R_MICROMIPS_GOT_PAGE:
7791         case R_MICROMIPS_GOT_OFST:
7792         case R_MICROMIPS_GOT_DISP:
7793         case R_MICROMIPS_TLS_GOTTPREL:
7794         case R_MICROMIPS_TLS_GD:
7795         case R_MICROMIPS_TLS_LDM:
7796           if (dynobj == NULL)
7797             elf_hash_table (info)->dynobj = dynobj = abfd;
7798           if (!mips_elf_create_got_section (dynobj, info))
7799             return FALSE;
7800           if (htab->is_vxworks && !info->shared)
7801             {
7802               (*_bfd_error_handler)
7803                 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7804                  abfd, (unsigned long) rel->r_offset);
7805               bfd_set_error (bfd_error_bad_value);
7806               return FALSE;
7807             }
7808           break;
7809
7810           /* This is just a hint; it can safely be ignored.  Don't set
7811              has_static_relocs for the corresponding symbol.  */
7812         case R_MIPS_JALR:
7813         case R_MICROMIPS_JALR:
7814           break;
7815
7816         case R_MIPS_32:
7817         case R_MIPS_REL32:
7818         case R_MIPS_64:
7819           /* In VxWorks executables, references to external symbols
7820              must be handled using copy relocs or PLT entries; it is not
7821              possible to convert this relocation into a dynamic one.
7822
7823              For executables that use PLTs and copy-relocs, we have a
7824              choice between converting the relocation into a dynamic
7825              one or using copy relocations or PLT entries.  It is
7826              usually better to do the former, unless the relocation is
7827              against a read-only section.  */
7828           if ((info->shared
7829                || (h != NULL
7830                    && !htab->is_vxworks
7831                    && strcmp (h->root.root.string, "__gnu_local_gp") != 0
7832                    && !(!info->nocopyreloc
7833                         && !PIC_OBJECT_P (abfd)
7834                         && MIPS_ELF_READONLY_SECTION (sec))))
7835               && (sec->flags & SEC_ALLOC) != 0)
7836             {
7837               can_make_dynamic_p = TRUE;
7838               if (dynobj == NULL)
7839                 elf_hash_table (info)->dynobj = dynobj = abfd;
7840               break;
7841             }
7842           /* For sections that are not SEC_ALLOC a copy reloc would be
7843              output if possible (implying questionable semantics for
7844              read-only data objects) or otherwise the final link would
7845              fail as ld.so will not process them and could not therefore
7846              handle any outstanding dynamic relocations.
7847
7848              For such sections that are also SEC_DEBUGGING, we can avoid
7849              these problems by simply ignoring any relocs as these
7850              sections have a predefined use and we know it is safe to do
7851              so.
7852
7853              This is needed in cases such as a global symbol definition
7854              in a shared library causing a common symbol from an object
7855              file to be converted to an undefined reference.  If that
7856              happens, then all the relocations against this symbol from
7857              SEC_DEBUGGING sections in the object file will resolve to
7858              nil.  */
7859           if ((sec->flags & SEC_DEBUGGING) != 0)
7860             break;
7861           /* Fall through.  */
7862
7863         default:
7864           /* Most static relocations require pointer equality, except
7865              for branches.  */
7866           if (h)
7867             h->pointer_equality_needed = TRUE;
7868           /* Fall through.  */
7869
7870         case R_MIPS_26:
7871         case R_MIPS_PC16:
7872         case R_MIPS16_26:
7873         case R_MICROMIPS_26_S1:
7874         case R_MICROMIPS_PC7_S1:
7875         case R_MICROMIPS_PC10_S1:
7876         case R_MICROMIPS_PC16_S1:
7877         case R_MICROMIPS_PC23_S2:
7878           if (h)
7879             ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = TRUE;
7880           break;
7881         }
7882
7883       if (h)
7884         {
7885           /* Relocations against the special VxWorks __GOTT_BASE__ and
7886              __GOTT_INDEX__ symbols must be left to the loader.  Allocate
7887              room for them in .rela.dyn.  */
7888           if (is_gott_symbol (info, h))
7889             {
7890               if (sreloc == NULL)
7891                 {
7892                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
7893                   if (sreloc == NULL)
7894                     return FALSE;
7895                 }
7896               mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7897               if (MIPS_ELF_READONLY_SECTION (sec))
7898                 /* We tell the dynamic linker that there are
7899                    relocations against the text segment.  */
7900                 info->flags |= DF_TEXTREL;
7901             }
7902         }
7903       else if (call_lo16_reloc_p (r_type)
7904                || got_lo16_reloc_p (r_type)
7905                || got_disp_reloc_p (r_type)
7906                || (got16_reloc_p (r_type) && htab->is_vxworks))
7907         {
7908           /* We may need a local GOT entry for this relocation.  We
7909              don't count R_MIPS_GOT_PAGE because we can estimate the
7910              maximum number of pages needed by looking at the size of
7911              the segment.  Similar comments apply to R_MIPS*_GOT16 and
7912              R_MIPS*_CALL16, except on VxWorks, where GOT relocations
7913              always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
7914              R_MIPS_CALL_HI16 because these are always followed by an
7915              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
7916           if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
7917                                                  rel->r_addend, info, 0))
7918             return FALSE;
7919         }
7920
7921       if (h != NULL && mips_elf_relocation_needs_la25_stub (abfd, r_type))
7922         ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
7923
7924       switch (r_type)
7925         {
7926         case R_MIPS_CALL16:
7927         case R_MIPS16_CALL16:
7928         case R_MICROMIPS_CALL16:
7929           if (h == NULL)
7930             {
7931               (*_bfd_error_handler)
7932                 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
7933                  abfd, (unsigned long) rel->r_offset);
7934               bfd_set_error (bfd_error_bad_value);
7935               return FALSE;
7936             }
7937           /* Fall through.  */
7938
7939         case R_MIPS_CALL_HI16:
7940         case R_MIPS_CALL_LO16:
7941         case R_MICROMIPS_CALL_HI16:
7942         case R_MICROMIPS_CALL_LO16:
7943           if (h != NULL)
7944             {
7945               /* Make sure there is room in the regular GOT to hold the
7946                  function's address.  We may eliminate it in favour of
7947                  a .got.plt entry later; see mips_elf_count_got_symbols.  */
7948               if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE, 0))
7949                 return FALSE;
7950
7951               /* We need a stub, not a plt entry for the undefined
7952                  function.  But we record it as if it needs plt.  See
7953                  _bfd_elf_adjust_dynamic_symbol.  */
7954               h->needs_plt = 1;
7955               h->type = STT_FUNC;
7956             }
7957           break;
7958
7959         case R_MIPS_GOT_PAGE:
7960         case R_MICROMIPS_GOT_PAGE:
7961           /* If this is a global, overridable symbol, GOT_PAGE will
7962              decay to GOT_DISP, so we'll need a GOT entry for it.  */
7963           if (h)
7964             {
7965               struct mips_elf_link_hash_entry *hmips =
7966                 (struct mips_elf_link_hash_entry *) h;
7967
7968               /* This symbol is definitely not overridable.  */
7969               if (hmips->root.def_regular
7970                   && ! (info->shared && ! info->symbolic
7971                         && ! hmips->root.forced_local))
7972                 h = NULL;
7973             }
7974           /* Fall through.  */
7975
7976         case R_MIPS16_GOT16:
7977         case R_MIPS_GOT16:
7978         case R_MIPS_GOT_HI16:
7979         case R_MIPS_GOT_LO16:
7980         case R_MICROMIPS_GOT16:
7981         case R_MICROMIPS_GOT_HI16:
7982         case R_MICROMIPS_GOT_LO16:
7983           if (!h || got_page_reloc_p (r_type))
7984             {
7985               /* This relocation needs (or may need, if h != NULL) a
7986                  page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
7987                  know for sure until we know whether the symbol is
7988                  preemptible.  */
7989               if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
7990                 {
7991                   if (!mips_elf_get_section_contents (abfd, sec, &contents))
7992                     return FALSE;
7993                   howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
7994                   addend = mips_elf_read_rel_addend (abfd, rel,
7995                                                      howto, contents);
7996                   if (got16_reloc_p (r_type))
7997                     mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
7998                                                   contents, &addend);
7999                   else
8000                     addend <<= howto->rightshift;
8001                 }
8002               else
8003                 addend = rel->r_addend;
8004               if (!mips_elf_record_got_page_entry (info, abfd, r_symndx,
8005                                                    addend))
8006                 return FALSE;
8007             }
8008           /* Fall through.  */
8009
8010         case R_MIPS_GOT_DISP:
8011         case R_MICROMIPS_GOT_DISP:
8012           if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8013                                                        FALSE, 0))
8014             return FALSE;
8015           break;
8016
8017         case R_MIPS_TLS_GOTTPREL:
8018         case R_MICROMIPS_TLS_GOTTPREL:
8019           if (info->shared)
8020             info->flags |= DF_STATIC_TLS;
8021           /* Fall through */
8022
8023         case R_MIPS_TLS_LDM:
8024         case R_MICROMIPS_TLS_LDM:
8025           if (tls_ldm_reloc_p (r_type))
8026             {
8027               r_symndx = STN_UNDEF;
8028               h = NULL;
8029             }
8030           /* Fall through */
8031
8032         case R_MIPS_TLS_GD:
8033         case R_MICROMIPS_TLS_GD:
8034           /* This symbol requires a global offset table entry, or two
8035              for TLS GD relocations.  */
8036           {
8037             unsigned char flag;
8038
8039             flag = (tls_gd_reloc_p (r_type)
8040                     ? GOT_TLS_GD
8041                     : tls_ldm_reloc_p (r_type) ? GOT_TLS_LDM : GOT_TLS_IE);
8042             if (h != NULL)
8043               {
8044                 struct mips_elf_link_hash_entry *hmips =
8045                   (struct mips_elf_link_hash_entry *) h;
8046                 hmips->tls_type |= flag;
8047
8048                 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8049                                                              FALSE, flag))
8050                   return FALSE;
8051               }
8052             else
8053               {
8054                 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != STN_UNDEF);
8055
8056                 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8057                                                        rel->r_addend,
8058                                                        info, flag))
8059                   return FALSE;
8060               }
8061           }
8062           break;
8063
8064         case R_MIPS_32:
8065         case R_MIPS_REL32:
8066         case R_MIPS_64:
8067           /* In VxWorks executables, references to external symbols
8068              are handled using copy relocs or PLT stubs, so there's
8069              no need to add a .rela.dyn entry for this relocation.  */
8070           if (can_make_dynamic_p)
8071             {
8072               if (sreloc == NULL)
8073                 {
8074                   sreloc = mips_elf_rel_dyn_section (info, TRUE);
8075                   if (sreloc == NULL)
8076                     return FALSE;
8077                 }
8078               if (info->shared && h == NULL)
8079                 {
8080                   /* When creating a shared object, we must copy these
8081                      reloc types into the output file as R_MIPS_REL32
8082                      relocs.  Make room for this reloc in .rel(a).dyn.  */
8083                   mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8084                   if (MIPS_ELF_READONLY_SECTION (sec))
8085                     /* We tell the dynamic linker that there are
8086                        relocations against the text segment.  */
8087                     info->flags |= DF_TEXTREL;
8088                 }
8089               else
8090                 {
8091                   struct mips_elf_link_hash_entry *hmips;
8092
8093                   /* For a shared object, we must copy this relocation
8094                      unless the symbol turns out to be undefined and
8095                      weak with non-default visibility, in which case
8096                      it will be left as zero.
8097
8098                      We could elide R_MIPS_REL32 for locally binding symbols
8099                      in shared libraries, but do not yet do so.
8100
8101                      For an executable, we only need to copy this
8102                      reloc if the symbol is defined in a dynamic
8103                      object.  */
8104                   hmips = (struct mips_elf_link_hash_entry *) h;
8105                   ++hmips->possibly_dynamic_relocs;
8106                   if (MIPS_ELF_READONLY_SECTION (sec))
8107                     /* We need it to tell the dynamic linker if there
8108                        are relocations against the text segment.  */
8109                     hmips->readonly_reloc = TRUE;
8110                 }
8111             }
8112
8113           if (SGI_COMPAT (abfd))
8114             mips_elf_hash_table (info)->compact_rel_size +=
8115               sizeof (Elf32_External_crinfo);
8116           break;
8117
8118         case R_MIPS_26:
8119         case R_MIPS_GPREL16:
8120         case R_MIPS_LITERAL:
8121         case R_MIPS_GPREL32:
8122         case R_MICROMIPS_26_S1:
8123         case R_MICROMIPS_GPREL16:
8124         case R_MICROMIPS_LITERAL:
8125         case R_MICROMIPS_GPREL7_S2:
8126           if (SGI_COMPAT (abfd))
8127             mips_elf_hash_table (info)->compact_rel_size +=
8128               sizeof (Elf32_External_crinfo);
8129           break;
8130
8131           /* This relocation describes the C++ object vtable hierarchy.
8132              Reconstruct it for later use during GC.  */
8133         case R_MIPS_GNU_VTINHERIT:
8134           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8135             return FALSE;
8136           break;
8137
8138           /* This relocation describes which C++ vtable entries are actually
8139              used.  Record for later use during GC.  */
8140         case R_MIPS_GNU_VTENTRY:
8141           BFD_ASSERT (h != NULL);
8142           if (h != NULL
8143               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8144             return FALSE;
8145           break;
8146
8147         default:
8148           break;
8149         }
8150
8151       /* We must not create a stub for a symbol that has relocations
8152          related to taking the function's address.  This doesn't apply to
8153          VxWorks, where CALL relocs refer to a .got.plt entry instead of
8154          a normal .got entry.  */
8155       if (!htab->is_vxworks && h != NULL)
8156         switch (r_type)
8157           {
8158           default:
8159             ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8160             break;
8161           case R_MIPS16_CALL16:
8162           case R_MIPS_CALL16:
8163           case R_MIPS_CALL_HI16:
8164           case R_MIPS_CALL_LO16:
8165           case R_MIPS_JALR:
8166           case R_MICROMIPS_CALL16:
8167           case R_MICROMIPS_CALL_HI16:
8168           case R_MICROMIPS_CALL_LO16:
8169           case R_MICROMIPS_JALR:
8170             break;
8171           }
8172
8173       /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8174          if there is one.  We only need to handle global symbols here;
8175          we decide whether to keep or delete stubs for local symbols
8176          when processing the stub's relocations.  */
8177       if (h != NULL
8178           && !mips16_call_reloc_p (r_type)
8179           && !section_allows_mips16_refs_p (sec))
8180         {
8181           struct mips_elf_link_hash_entry *mh;
8182
8183           mh = (struct mips_elf_link_hash_entry *) h;
8184           mh->need_fn_stub = TRUE;
8185         }
8186
8187       /* Refuse some position-dependent relocations when creating a
8188          shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
8189          not PIC, but we can create dynamic relocations and the result
8190          will be fine.  Also do not refuse R_MIPS_LO16, which can be
8191          combined with R_MIPS_GOT16.  */
8192       if (info->shared)
8193         {
8194           switch (r_type)
8195             {
8196             case R_MIPS16_HI16:
8197             case R_MIPS_HI16:
8198             case R_MIPS_HIGHER:
8199             case R_MIPS_HIGHEST:
8200             case R_MICROMIPS_HI16:
8201             case R_MICROMIPS_HIGHER:
8202             case R_MICROMIPS_HIGHEST:
8203               /* Don't refuse a high part relocation if it's against
8204                  no symbol (e.g. part of a compound relocation).  */
8205               if (r_symndx == STN_UNDEF)
8206                 break;
8207
8208               /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8209                  and has a special meaning.  */
8210               if (!NEWABI_P (abfd) && h != NULL
8211                   && strcmp (h->root.root.string, "_gp_disp") == 0)
8212                 break;
8213
8214               /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks.  */
8215               if (is_gott_symbol (info, h))
8216                 break;
8217
8218               /* FALLTHROUGH */
8219
8220             case R_MIPS16_26:
8221             case R_MIPS_26:
8222             case R_MICROMIPS_26_S1:
8223               howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8224               (*_bfd_error_handler)
8225                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8226                  abfd, howto->name,
8227                  (h) ? h->root.root.string : "a local symbol");
8228               bfd_set_error (bfd_error_bad_value);
8229               return FALSE;
8230             default:
8231               break;
8232             }
8233         }
8234     }
8235
8236   return TRUE;
8237 }
8238 \f
8239 bfd_boolean
8240 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8241                          struct bfd_link_info *link_info,
8242                          bfd_boolean *again)
8243 {
8244   Elf_Internal_Rela *internal_relocs;
8245   Elf_Internal_Rela *irel, *irelend;
8246   Elf_Internal_Shdr *symtab_hdr;
8247   bfd_byte *contents = NULL;
8248   size_t extsymoff;
8249   bfd_boolean changed_contents = FALSE;
8250   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8251   Elf_Internal_Sym *isymbuf = NULL;
8252
8253   /* We are not currently changing any sizes, so only one pass.  */
8254   *again = FALSE;
8255
8256   if (link_info->relocatable)
8257     return TRUE;
8258
8259   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8260                                                link_info->keep_memory);
8261   if (internal_relocs == NULL)
8262     return TRUE;
8263
8264   irelend = internal_relocs + sec->reloc_count
8265     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8266   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8267   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8268
8269   for (irel = internal_relocs; irel < irelend; irel++)
8270     {
8271       bfd_vma symval;
8272       bfd_signed_vma sym_offset;
8273       unsigned int r_type;
8274       unsigned long r_symndx;
8275       asection *sym_sec;
8276       unsigned long instruction;
8277
8278       /* Turn jalr into bgezal, and jr into beq, if they're marked
8279          with a JALR relocation, that indicate where they jump to.
8280          This saves some pipeline bubbles.  */
8281       r_type = ELF_R_TYPE (abfd, irel->r_info);
8282       if (r_type != R_MIPS_JALR)
8283         continue;
8284
8285       r_symndx = ELF_R_SYM (abfd, irel->r_info);
8286       /* Compute the address of the jump target.  */
8287       if (r_symndx >= extsymoff)
8288         {
8289           struct mips_elf_link_hash_entry *h
8290             = ((struct mips_elf_link_hash_entry *)
8291                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8292
8293           while (h->root.root.type == bfd_link_hash_indirect
8294                  || h->root.root.type == bfd_link_hash_warning)
8295             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8296
8297           /* If a symbol is undefined, or if it may be overridden,
8298              skip it.  */
8299           if (! ((h->root.root.type == bfd_link_hash_defined
8300                   || h->root.root.type == bfd_link_hash_defweak)
8301                  && h->root.root.u.def.section)
8302               || (link_info->shared && ! link_info->symbolic
8303                   && !h->root.forced_local))
8304             continue;
8305
8306           sym_sec = h->root.root.u.def.section;
8307           if (sym_sec->output_section)
8308             symval = (h->root.root.u.def.value
8309                       + sym_sec->output_section->vma
8310                       + sym_sec->output_offset);
8311           else
8312             symval = h->root.root.u.def.value;
8313         }
8314       else
8315         {
8316           Elf_Internal_Sym *isym;
8317
8318           /* Read this BFD's symbols if we haven't done so already.  */
8319           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8320             {
8321               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8322               if (isymbuf == NULL)
8323                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8324                                                 symtab_hdr->sh_info, 0,
8325                                                 NULL, NULL, NULL);
8326               if (isymbuf == NULL)
8327                 goto relax_return;
8328             }
8329
8330           isym = isymbuf + r_symndx;
8331           if (isym->st_shndx == SHN_UNDEF)
8332             continue;
8333           else if (isym->st_shndx == SHN_ABS)
8334             sym_sec = bfd_abs_section_ptr;
8335           else if (isym->st_shndx == SHN_COMMON)
8336             sym_sec = bfd_com_section_ptr;
8337           else
8338             sym_sec
8339               = bfd_section_from_elf_index (abfd, isym->st_shndx);
8340           symval = isym->st_value
8341             + sym_sec->output_section->vma
8342             + sym_sec->output_offset;
8343         }
8344
8345       /* Compute branch offset, from delay slot of the jump to the
8346          branch target.  */
8347       sym_offset = (symval + irel->r_addend)
8348         - (sec_start + irel->r_offset + 4);
8349
8350       /* Branch offset must be properly aligned.  */
8351       if ((sym_offset & 3) != 0)
8352         continue;
8353
8354       sym_offset >>= 2;
8355
8356       /* Check that it's in range.  */
8357       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8358         continue;
8359
8360       /* Get the section contents if we haven't done so already.  */
8361       if (!mips_elf_get_section_contents (abfd, sec, &contents))
8362         goto relax_return;
8363
8364       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8365
8366       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
8367       if ((instruction & 0xfc1fffff) == 0x0000f809)
8368         instruction = 0x04110000;
8369       /* If it was jr <reg>, turn it into b <target>.  */
8370       else if ((instruction & 0xfc1fffff) == 0x00000008)
8371         instruction = 0x10000000;
8372       else
8373         continue;
8374
8375       instruction |= (sym_offset & 0xffff);
8376       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8377       changed_contents = TRUE;
8378     }
8379
8380   if (contents != NULL
8381       && elf_section_data (sec)->this_hdr.contents != contents)
8382     {
8383       if (!changed_contents && !link_info->keep_memory)
8384         free (contents);
8385       else
8386         {
8387           /* Cache the section contents for elf_link_input_bfd.  */
8388           elf_section_data (sec)->this_hdr.contents = contents;
8389         }
8390     }
8391   return TRUE;
8392
8393  relax_return:
8394   if (contents != NULL
8395       && elf_section_data (sec)->this_hdr.contents != contents)
8396     free (contents);
8397   return FALSE;
8398 }
8399 \f
8400 /* Allocate space for global sym dynamic relocs.  */
8401
8402 static bfd_boolean
8403 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8404 {
8405   struct bfd_link_info *info = inf;
8406   bfd *dynobj;
8407   struct mips_elf_link_hash_entry *hmips;
8408   struct mips_elf_link_hash_table *htab;
8409
8410   htab = mips_elf_hash_table (info);
8411   BFD_ASSERT (htab != NULL);
8412
8413   dynobj = elf_hash_table (info)->dynobj;
8414   hmips = (struct mips_elf_link_hash_entry *) h;
8415
8416   /* VxWorks executables are handled elsewhere; we only need to
8417      allocate relocations in shared objects.  */
8418   if (htab->is_vxworks && !info->shared)
8419     return TRUE;
8420
8421   /* Ignore indirect symbols.  All relocations against such symbols
8422      will be redirected to the target symbol.  */
8423   if (h->root.type == bfd_link_hash_indirect)
8424     return TRUE;
8425
8426   /* If this symbol is defined in a dynamic object, or we are creating
8427      a shared library, we will need to copy any R_MIPS_32 or
8428      R_MIPS_REL32 relocs against it into the output file.  */
8429   if (! info->relocatable
8430       && hmips->possibly_dynamic_relocs != 0
8431       && (h->root.type == bfd_link_hash_defweak
8432           || !h->def_regular
8433           || info->shared))
8434     {
8435       bfd_boolean do_copy = TRUE;
8436
8437       if (h->root.type == bfd_link_hash_undefweak)
8438         {
8439           /* Do not copy relocations for undefined weak symbols with
8440              non-default visibility.  */
8441           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8442             do_copy = FALSE;
8443
8444           /* Make sure undefined weak symbols are output as a dynamic
8445              symbol in PIEs.  */
8446           else if (h->dynindx == -1 && !h->forced_local)
8447             {
8448               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8449                 return FALSE;
8450             }
8451         }
8452
8453       if (do_copy)
8454         {
8455           /* Even though we don't directly need a GOT entry for this symbol,
8456              the SVR4 psABI requires it to have a dynamic symbol table
8457              index greater that DT_MIPS_GOTSYM if there are dynamic
8458              relocations against it.
8459
8460              VxWorks does not enforce the same mapping between the GOT
8461              and the symbol table, so the same requirement does not
8462              apply there.  */
8463           if (!htab->is_vxworks)
8464             {
8465               if (hmips->global_got_area > GGA_RELOC_ONLY)
8466                 hmips->global_got_area = GGA_RELOC_ONLY;
8467               hmips->got_only_for_calls = FALSE;
8468             }
8469
8470           mips_elf_allocate_dynamic_relocations
8471             (dynobj, info, hmips->possibly_dynamic_relocs);
8472           if (hmips->readonly_reloc)
8473             /* We tell the dynamic linker that there are relocations
8474                against the text segment.  */
8475             info->flags |= DF_TEXTREL;
8476         }
8477     }
8478
8479   return TRUE;
8480 }
8481
8482 /* Adjust a symbol defined by a dynamic object and referenced by a
8483    regular object.  The current definition is in some section of the
8484    dynamic object, but we're not including those sections.  We have to
8485    change the definition to something the rest of the link can
8486    understand.  */
8487
8488 bfd_boolean
8489 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8490                                      struct elf_link_hash_entry *h)
8491 {
8492   bfd *dynobj;
8493   struct mips_elf_link_hash_entry *hmips;
8494   struct mips_elf_link_hash_table *htab;
8495
8496   htab = mips_elf_hash_table (info);
8497   BFD_ASSERT (htab != NULL);
8498
8499   dynobj = elf_hash_table (info)->dynobj;
8500   hmips = (struct mips_elf_link_hash_entry *) h;
8501
8502   /* Make sure we know what is going on here.  */
8503   BFD_ASSERT (dynobj != NULL
8504               && (h->needs_plt
8505                   || h->u.weakdef != NULL
8506                   || (h->def_dynamic
8507                       && h->ref_regular
8508                       && !h->def_regular)));
8509
8510   hmips = (struct mips_elf_link_hash_entry *) h;
8511
8512   /* If there are call relocations against an externally-defined symbol,
8513      see whether we can create a MIPS lazy-binding stub for it.  We can
8514      only do this if all references to the function are through call
8515      relocations, and in that case, the traditional lazy-binding stubs
8516      are much more efficient than PLT entries.
8517
8518      Traditional stubs are only available on SVR4 psABI-based systems;
8519      VxWorks always uses PLTs instead.  */
8520   if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
8521     {
8522       if (! elf_hash_table (info)->dynamic_sections_created)
8523         return TRUE;
8524
8525       /* If this symbol is not defined in a regular file, then set
8526          the symbol to the stub location.  This is required to make
8527          function pointers compare as equal between the normal
8528          executable and the shared library.  */
8529       if (!h->def_regular)
8530         {
8531           hmips->needs_lazy_stub = TRUE;
8532           htab->lazy_stub_count++;
8533           return TRUE;
8534         }
8535     }
8536   /* As above, VxWorks requires PLT entries for externally-defined
8537      functions that are only accessed through call relocations.
8538
8539      Both VxWorks and non-VxWorks targets also need PLT entries if there
8540      are static-only relocations against an externally-defined function.
8541      This can technically occur for shared libraries if there are
8542      branches to the symbol, although it is unlikely that this will be
8543      used in practice due to the short ranges involved.  It can occur
8544      for any relative or absolute relocation in executables; in that
8545      case, the PLT entry becomes the function's canonical address.  */
8546   else if (((h->needs_plt && !hmips->no_fn_stub)
8547             || (h->type == STT_FUNC && hmips->has_static_relocs))
8548            && htab->use_plts_and_copy_relocs
8549            && !SYMBOL_CALLS_LOCAL (info, h)
8550            && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
8551                 && h->root.type == bfd_link_hash_undefweak))
8552     {
8553       /* If this is the first symbol to need a PLT entry, allocate room
8554          for the header.  */
8555       if (htab->splt->size == 0)
8556         {
8557           BFD_ASSERT (htab->sgotplt->size == 0);
8558
8559           /* If we're using the PLT additions to the psABI, each PLT
8560              entry is 16 bytes and the PLT0 entry is 32 bytes.
8561              Encourage better cache usage by aligning.  We do this
8562              lazily to avoid pessimizing traditional objects.  */
8563           if (!htab->is_vxworks
8564               && !bfd_set_section_alignment (dynobj, htab->splt, 5))
8565             return FALSE;
8566
8567           /* Make sure that .got.plt is word-aligned.  We do this lazily
8568              for the same reason as above.  */
8569           if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
8570                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
8571             return FALSE;
8572
8573           htab->splt->size += htab->plt_header_size;
8574
8575           /* On non-VxWorks targets, the first two entries in .got.plt
8576              are reserved.  */
8577           if (!htab->is_vxworks)
8578             htab->sgotplt->size += 2 * MIPS_ELF_GOT_SIZE (dynobj);
8579
8580           /* On VxWorks, also allocate room for the header's
8581              .rela.plt.unloaded entries.  */
8582           if (htab->is_vxworks && !info->shared)
8583             htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
8584         }
8585
8586       /* Assign the next .plt entry to this symbol.  */
8587       h->plt.offset = htab->splt->size;
8588       htab->splt->size += htab->plt_entry_size;
8589
8590       /* If the output file has no definition of the symbol, set the
8591          symbol's value to the address of the stub.  */
8592       if (!info->shared && !h->def_regular)
8593         {
8594           h->root.u.def.section = htab->splt;
8595           h->root.u.def.value = h->plt.offset;
8596           /* For VxWorks, point at the PLT load stub rather than the
8597              lazy resolution stub; this stub will become the canonical
8598              function address.  */
8599           if (htab->is_vxworks)
8600             h->root.u.def.value += 8;
8601         }
8602
8603       /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8604          relocation.  */
8605       htab->sgotplt->size += MIPS_ELF_GOT_SIZE (dynobj);
8606       htab->srelplt->size += (htab->is_vxworks
8607                               ? MIPS_ELF_RELA_SIZE (dynobj)
8608                               : MIPS_ELF_REL_SIZE (dynobj));
8609
8610       /* Make room for the .rela.plt.unloaded relocations.  */
8611       if (htab->is_vxworks && !info->shared)
8612         htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
8613
8614       /* All relocations against this symbol that could have been made
8615          dynamic will now refer to the PLT entry instead.  */
8616       hmips->possibly_dynamic_relocs = 0;
8617
8618       return TRUE;
8619     }
8620
8621   /* If this is a weak symbol, and there is a real definition, the
8622      processor independent code will have arranged for us to see the
8623      real definition first, and we can just use the same value.  */
8624   if (h->u.weakdef != NULL)
8625     {
8626       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
8627                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
8628       h->root.u.def.section = h->u.weakdef->root.u.def.section;
8629       h->root.u.def.value = h->u.weakdef->root.u.def.value;
8630       return TRUE;
8631     }
8632
8633   /* Otherwise, there is nothing further to do for symbols defined
8634      in regular objects.  */
8635   if (h->def_regular)
8636     return TRUE;
8637
8638   /* There's also nothing more to do if we'll convert all relocations
8639      against this symbol into dynamic relocations.  */
8640   if (!hmips->has_static_relocs)
8641     return TRUE;
8642
8643   /* We're now relying on copy relocations.  Complain if we have
8644      some that we can't convert.  */
8645   if (!htab->use_plts_and_copy_relocs || info->shared)
8646     {
8647       (*_bfd_error_handler) (_("non-dynamic relocations refer to "
8648                                "dynamic symbol %s"),
8649                              h->root.root.string);
8650       bfd_set_error (bfd_error_bad_value);
8651       return FALSE;
8652     }
8653
8654   /* We must allocate the symbol in our .dynbss section, which will
8655      become part of the .bss section of the executable.  There will be
8656      an entry for this symbol in the .dynsym section.  The dynamic
8657      object will contain position independent code, so all references
8658      from the dynamic object to this symbol will go through the global
8659      offset table.  The dynamic linker will use the .dynsym entry to
8660      determine the address it must put in the global offset table, so
8661      both the dynamic object and the regular object will refer to the
8662      same memory location for the variable.  */
8663
8664   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
8665     {
8666       if (htab->is_vxworks)
8667         htab->srelbss->size += sizeof (Elf32_External_Rela);
8668       else
8669         mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8670       h->needs_copy = 1;
8671     }
8672
8673   /* All relocations against this symbol that could have been made
8674      dynamic will now refer to the local copy instead.  */
8675   hmips->possibly_dynamic_relocs = 0;
8676
8677   return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
8678 }
8679 \f
8680 /* This function is called after all the input files have been read,
8681    and the input sections have been assigned to output sections.  We
8682    check for any mips16 stub sections that we can discard.  */
8683
8684 bfd_boolean
8685 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
8686                                     struct bfd_link_info *info)
8687 {
8688   asection *ri;
8689   struct mips_elf_link_hash_table *htab;
8690   struct mips_htab_traverse_info hti;
8691
8692   htab = mips_elf_hash_table (info);
8693   BFD_ASSERT (htab != NULL);
8694
8695   /* The .reginfo section has a fixed size.  */
8696   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8697   if (ri != NULL)
8698     bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8699
8700   hti.info = info;
8701   hti.output_bfd = output_bfd;
8702   hti.error = FALSE;
8703   mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8704                                mips_elf_check_symbols, &hti);
8705   if (hti.error)
8706     return FALSE;
8707
8708   return TRUE;
8709 }
8710
8711 /* If the link uses a GOT, lay it out and work out its size.  */
8712
8713 static bfd_boolean
8714 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
8715 {
8716   bfd *dynobj;
8717   asection *s;
8718   struct mips_got_info *g;
8719   bfd_size_type loadable_size = 0;
8720   bfd_size_type page_gotno;
8721   bfd *sub;
8722   struct mips_elf_count_tls_arg count_tls_arg;
8723   struct mips_elf_link_hash_table *htab;
8724
8725   htab = mips_elf_hash_table (info);
8726   BFD_ASSERT (htab != NULL);
8727
8728   s = htab->sgot;
8729   if (s == NULL)
8730     return TRUE;
8731
8732   dynobj = elf_hash_table (info)->dynobj;
8733   g = htab->got_info;
8734
8735   /* Allocate room for the reserved entries.  VxWorks always reserves
8736      3 entries; other objects only reserve 2 entries.  */
8737   BFD_ASSERT (g->assigned_gotno == 0);
8738   if (htab->is_vxworks)
8739     htab->reserved_gotno = 3;
8740   else
8741     htab->reserved_gotno = 2;
8742   g->local_gotno += htab->reserved_gotno;
8743   g->assigned_gotno = htab->reserved_gotno;
8744
8745   /* Replace entries for indirect and warning symbols with entries for
8746      the target symbol.  */
8747   if (!mips_elf_resolve_final_got_entries (g))
8748     return FALSE;
8749
8750   /* Count the number of GOT symbols.  */
8751   mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
8752
8753   /* Calculate the total loadable size of the output.  That
8754      will give us the maximum number of GOT_PAGE entries
8755      required.  */
8756   for (sub = info->input_bfds; sub; sub = sub->link_next)
8757     {
8758       asection *subsection;
8759
8760       for (subsection = sub->sections;
8761            subsection;
8762            subsection = subsection->next)
8763         {
8764           if ((subsection->flags & SEC_ALLOC) == 0)
8765             continue;
8766           loadable_size += ((subsection->size + 0xf)
8767                             &~ (bfd_size_type) 0xf);
8768         }
8769     }
8770
8771   if (htab->is_vxworks)
8772     /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8773        relocations against local symbols evaluate to "G", and the EABI does
8774        not include R_MIPS_GOT_PAGE.  */
8775     page_gotno = 0;
8776   else
8777     /* Assume there are two loadable segments consisting of contiguous
8778        sections.  Is 5 enough?  */
8779     page_gotno = (loadable_size >> 16) + 5;
8780
8781   /* Choose the smaller of the two estimates; both are intended to be
8782      conservative.  */
8783   if (page_gotno > g->page_gotno)
8784     page_gotno = g->page_gotno;
8785
8786   g->local_gotno += page_gotno;
8787   s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8788   s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8789
8790   /* We need to calculate tls_gotno for global symbols at this point
8791      instead of building it up earlier, to avoid doublecounting
8792      entries for one global symbol from multiple input files.  */
8793   count_tls_arg.info = info;
8794   count_tls_arg.needed = 0;
8795   elf_link_hash_traverse (elf_hash_table (info),
8796                           mips_elf_count_global_tls_entries,
8797                           &count_tls_arg);
8798   g->tls_gotno += count_tls_arg.needed;
8799   s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8800
8801   /* VxWorks does not support multiple GOTs.  It initializes $gp to
8802      __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8803      dynamic loader.  */
8804   if (htab->is_vxworks)
8805     {
8806       /* VxWorks executables do not need a GOT.  */
8807       if (info->shared)
8808         {
8809           /* Each VxWorks GOT entry needs an explicit relocation.  */
8810           unsigned int count;
8811
8812           count = g->global_gotno + g->local_gotno - htab->reserved_gotno;
8813           if (count)
8814             mips_elf_allocate_dynamic_relocations (dynobj, info, count);
8815         }
8816     }
8817   else if (s->size > MIPS_ELF_GOT_MAX_SIZE (info))
8818     {
8819       if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
8820         return FALSE;
8821     }
8822   else
8823     {
8824       struct mips_elf_count_tls_arg arg;
8825
8826       /* Set up TLS entries.  */
8827       g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
8828       htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
8829
8830       /* Allocate room for the TLS relocations.  */
8831       arg.info = info;
8832       arg.needed = 0;
8833       htab_traverse (g->got_entries, mips_elf_count_local_tls_relocs, &arg);
8834       elf_link_hash_traverse (elf_hash_table (info),
8835                               mips_elf_count_global_tls_relocs,
8836                               &arg);
8837       if (arg.needed)
8838         mips_elf_allocate_dynamic_relocations (dynobj, info, arg.needed);
8839     }
8840
8841   return TRUE;
8842 }
8843
8844 /* Estimate the size of the .MIPS.stubs section.  */
8845
8846 static void
8847 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
8848 {
8849   struct mips_elf_link_hash_table *htab;
8850   bfd_size_type dynsymcount;
8851
8852   htab = mips_elf_hash_table (info);
8853   BFD_ASSERT (htab != NULL);
8854
8855   if (htab->lazy_stub_count == 0)
8856     return;
8857
8858   /* IRIX rld assumes that a function stub isn't at the end of the .text
8859      section, so add a dummy entry to the end.  */
8860   htab->lazy_stub_count++;
8861
8862   /* Get a worst-case estimate of the number of dynamic symbols needed.
8863      At this point, dynsymcount does not account for section symbols
8864      and count_section_dynsyms may overestimate the number that will
8865      be needed.  */
8866   dynsymcount = (elf_hash_table (info)->dynsymcount
8867                  + count_section_dynsyms (output_bfd, info));
8868
8869   /* Determine the size of one stub entry.  */
8870   htab->function_stub_size = (dynsymcount > 0x10000
8871                               ? MIPS_FUNCTION_STUB_BIG_SIZE
8872                               : MIPS_FUNCTION_STUB_NORMAL_SIZE);
8873
8874   htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
8875 }
8876
8877 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8878    MIPS hash table.  If H needs a traditional MIPS lazy-binding stub,
8879    allocate an entry in the stubs section.  */
8880
8881 static bfd_boolean
8882 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void **data)
8883 {
8884   struct mips_elf_link_hash_table *htab;
8885
8886   htab = (struct mips_elf_link_hash_table *) data;
8887   if (h->needs_lazy_stub)
8888     {
8889       h->root.root.u.def.section = htab->sstubs;
8890       h->root.root.u.def.value = htab->sstubs->size;
8891       h->root.plt.offset = htab->sstubs->size;
8892       htab->sstubs->size += htab->function_stub_size;
8893     }
8894   return TRUE;
8895 }
8896
8897 /* Allocate offsets in the stubs section to each symbol that needs one.
8898    Set the final size of the .MIPS.stub section.  */
8899
8900 static void
8901 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
8902 {
8903   struct mips_elf_link_hash_table *htab;
8904
8905   htab = mips_elf_hash_table (info);
8906   BFD_ASSERT (htab != NULL);
8907
8908   if (htab->lazy_stub_count == 0)
8909     return;
8910
8911   htab->sstubs->size = 0;
8912   mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, htab);
8913   htab->sstubs->size += htab->function_stub_size;
8914   BFD_ASSERT (htab->sstubs->size
8915               == htab->lazy_stub_count * htab->function_stub_size);
8916 }
8917
8918 /* Set the sizes of the dynamic sections.  */
8919
8920 bfd_boolean
8921 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
8922                                      struct bfd_link_info *info)
8923 {
8924   bfd *dynobj;
8925   asection *s, *sreldyn;
8926   bfd_boolean reltext;
8927   struct mips_elf_link_hash_table *htab;
8928
8929   htab = mips_elf_hash_table (info);
8930   BFD_ASSERT (htab != NULL);
8931   dynobj = elf_hash_table (info)->dynobj;
8932   BFD_ASSERT (dynobj != NULL);
8933
8934   if (elf_hash_table (info)->dynamic_sections_created)
8935     {
8936       /* Set the contents of the .interp section to the interpreter.  */
8937       if (info->executable)
8938         {
8939           s = bfd_get_section_by_name (dynobj, ".interp");
8940           BFD_ASSERT (s != NULL);
8941           s->size
8942             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
8943           s->contents
8944             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
8945         }
8946
8947       /* Create a symbol for the PLT, if we know that we are using it.  */
8948       if (htab->splt && htab->splt->size > 0 && htab->root.hplt == NULL)
8949         {
8950           struct elf_link_hash_entry *h;
8951
8952           BFD_ASSERT (htab->use_plts_and_copy_relocs);
8953
8954           h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
8955                                            "_PROCEDURE_LINKAGE_TABLE_");
8956           htab->root.hplt = h;
8957           if (h == NULL)
8958             return FALSE;
8959           h->type = STT_FUNC;
8960         }
8961     }
8962
8963   /* Allocate space for global sym dynamic relocs.  */
8964   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
8965
8966   mips_elf_estimate_stub_size (output_bfd, info);
8967
8968   if (!mips_elf_lay_out_got (output_bfd, info))
8969     return FALSE;
8970
8971   mips_elf_lay_out_lazy_stubs (info);
8972
8973   /* The check_relocs and adjust_dynamic_symbol entry points have
8974      determined the sizes of the various dynamic sections.  Allocate
8975      memory for them.  */
8976   reltext = FALSE;
8977   for (s = dynobj->sections; s != NULL; s = s->next)
8978     {
8979       const char *name;
8980
8981       /* It's OK to base decisions on the section name, because none
8982          of the dynobj section names depend upon the input files.  */
8983       name = bfd_get_section_name (dynobj, s);
8984
8985       if ((s->flags & SEC_LINKER_CREATED) == 0)
8986         continue;
8987
8988       if (CONST_STRNEQ (name, ".rel"))
8989         {
8990           if (s->size != 0)
8991             {
8992               const char *outname;
8993               asection *target;
8994
8995               /* If this relocation section applies to a read only
8996                  section, then we probably need a DT_TEXTREL entry.
8997                  If the relocation section is .rel(a).dyn, we always
8998                  assert a DT_TEXTREL entry rather than testing whether
8999                  there exists a relocation to a read only section or
9000                  not.  */
9001               outname = bfd_get_section_name (output_bfd,
9002                                               s->output_section);
9003               target = bfd_get_section_by_name (output_bfd, outname + 4);
9004               if ((target != NULL
9005                    && (target->flags & SEC_READONLY) != 0
9006                    && (target->flags & SEC_ALLOC) != 0)
9007                   || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9008                 reltext = TRUE;
9009
9010               /* We use the reloc_count field as a counter if we need
9011                  to copy relocs into the output file.  */
9012               if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9013                 s->reloc_count = 0;
9014
9015               /* If combreloc is enabled, elf_link_sort_relocs() will
9016                  sort relocations, but in a different way than we do,
9017                  and before we're done creating relocations.  Also, it
9018                  will move them around between input sections'
9019                  relocation's contents, so our sorting would be
9020                  broken, so don't let it run.  */
9021               info->combreloc = 0;
9022             }
9023         }
9024       else if (! info->shared
9025                && ! mips_elf_hash_table (info)->use_rld_obj_head
9026                && CONST_STRNEQ (name, ".rld_map"))
9027         {
9028           /* We add a room for __rld_map.  It will be filled in by the
9029              rtld to contain a pointer to the _r_debug structure.  */
9030           s->size += 4;
9031         }
9032       else if (SGI_COMPAT (output_bfd)
9033                && CONST_STRNEQ (name, ".compact_rel"))
9034         s->size += mips_elf_hash_table (info)->compact_rel_size;
9035       else if (s == htab->splt)
9036         {
9037           /* If the last PLT entry has a branch delay slot, allocate
9038              room for an extra nop to fill the delay slot.  This is
9039              for CPUs without load interlocking.  */
9040           if (! LOAD_INTERLOCKS_P (output_bfd)
9041               && ! htab->is_vxworks && s->size > 0)
9042             s->size += 4;
9043         }
9044       else if (! CONST_STRNEQ (name, ".init")
9045                && s != htab->sgot
9046                && s != htab->sgotplt
9047                && s != htab->sstubs
9048                && s != htab->sdynbss)
9049         {
9050           /* It's not one of our sections, so don't allocate space.  */
9051           continue;
9052         }
9053
9054       if (s->size == 0)
9055         {
9056           s->flags |= SEC_EXCLUDE;
9057           continue;
9058         }
9059
9060       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9061         continue;
9062
9063       /* Allocate memory for the section contents.  */
9064       s->contents = bfd_zalloc (dynobj, s->size);
9065       if (s->contents == NULL)
9066         {
9067           bfd_set_error (bfd_error_no_memory);
9068           return FALSE;
9069         }
9070     }
9071
9072   if (elf_hash_table (info)->dynamic_sections_created)
9073     {
9074       /* Add some entries to the .dynamic section.  We fill in the
9075          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9076          must add the entries now so that we get the correct size for
9077          the .dynamic section.  */
9078
9079       /* SGI object has the equivalence of DT_DEBUG in the
9080          DT_MIPS_RLD_MAP entry.  This must come first because glibc
9081          only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
9082          looks at the first one it sees.  */
9083       if (!info->shared
9084           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9085         return FALSE;
9086
9087       /* The DT_DEBUG entry may be filled in by the dynamic linker and
9088          used by the debugger.  */
9089       if (info->executable
9090           && !SGI_COMPAT (output_bfd)
9091           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9092         return FALSE;
9093
9094       if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9095         info->flags |= DF_TEXTREL;
9096
9097       if ((info->flags & DF_TEXTREL) != 0)
9098         {
9099           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9100             return FALSE;
9101
9102           /* Clear the DF_TEXTREL flag.  It will be set again if we
9103              write out an actual text relocation; we may not, because
9104              at this point we do not know whether e.g. any .eh_frame
9105              absolute relocations have been converted to PC-relative.  */
9106           info->flags &= ~DF_TEXTREL;
9107         }
9108
9109       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
9110         return FALSE;
9111
9112       sreldyn = mips_elf_rel_dyn_section (info, FALSE);
9113       if (htab->is_vxworks)
9114         {
9115           /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
9116              use any of the DT_MIPS_* tags.  */
9117           if (sreldyn && sreldyn->size > 0)
9118             {
9119               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9120                 return FALSE;
9121
9122               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
9123                 return FALSE;
9124
9125               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
9126                 return FALSE;
9127             }
9128         }
9129       else
9130         {
9131           if (sreldyn && sreldyn->size > 0)
9132             {
9133               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
9134                 return FALSE;
9135
9136               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
9137                 return FALSE;
9138
9139               if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
9140                 return FALSE;
9141             }
9142
9143           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
9144             return FALSE;
9145
9146           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
9147             return FALSE;
9148
9149           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
9150             return FALSE;
9151
9152           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
9153             return FALSE;
9154
9155           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
9156             return FALSE;
9157
9158           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
9159             return FALSE;
9160
9161           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
9162             return FALSE;
9163
9164           if (IRIX_COMPAT (dynobj) == ict_irix5
9165               && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
9166             return FALSE;
9167
9168           if (IRIX_COMPAT (dynobj) == ict_irix6
9169               && (bfd_get_section_by_name
9170                   (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
9171               && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
9172             return FALSE;
9173         }
9174       if (htab->splt->size > 0)
9175         {
9176           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
9177             return FALSE;
9178
9179           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
9180             return FALSE;
9181
9182           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
9183             return FALSE;
9184
9185           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
9186             return FALSE;
9187         }
9188       if (htab->is_vxworks
9189           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
9190         return FALSE;
9191     }
9192
9193   return TRUE;
9194 }
9195 \f
9196 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9197    Adjust its R_ADDEND field so that it is correct for the output file.
9198    LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9199    and sections respectively; both use symbol indexes.  */
9200
9201 static void
9202 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
9203                         bfd *input_bfd, Elf_Internal_Sym *local_syms,
9204                         asection **local_sections, Elf_Internal_Rela *rel)
9205 {
9206   unsigned int r_type, r_symndx;
9207   Elf_Internal_Sym *sym;
9208   asection *sec;
9209
9210   if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9211     {
9212       r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9213       if (gprel16_reloc_p (r_type)
9214           || r_type == R_MIPS_GPREL32
9215           || literal_reloc_p (r_type))
9216         {
9217           rel->r_addend += _bfd_get_gp_value (input_bfd);
9218           rel->r_addend -= _bfd_get_gp_value (output_bfd);
9219         }
9220
9221       r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
9222       sym = local_syms + r_symndx;
9223
9224       /* Adjust REL's addend to account for section merging.  */
9225       if (!info->relocatable)
9226         {
9227           sec = local_sections[r_symndx];
9228           _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9229         }
9230
9231       /* This would normally be done by the rela_normal code in elflink.c.  */
9232       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9233         rel->r_addend += local_sections[r_symndx]->output_offset;
9234     }
9235 }
9236
9237 /* Relocate a MIPS ELF section.  */
9238
9239 bfd_boolean
9240 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
9241                                 bfd *input_bfd, asection *input_section,
9242                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
9243                                 Elf_Internal_Sym *local_syms,
9244                                 asection **local_sections)
9245 {
9246   Elf_Internal_Rela *rel;
9247   const Elf_Internal_Rela *relend;
9248   bfd_vma addend = 0;
9249   bfd_boolean use_saved_addend_p = FALSE;
9250   const struct elf_backend_data *bed;
9251
9252   bed = get_elf_backend_data (output_bfd);
9253   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
9254   for (rel = relocs; rel < relend; ++rel)
9255     {
9256       const char *name;
9257       bfd_vma value = 0;
9258       reloc_howto_type *howto;
9259       bfd_boolean cross_mode_jump_p;
9260       /* TRUE if the relocation is a RELA relocation, rather than a
9261          REL relocation.  */
9262       bfd_boolean rela_relocation_p = TRUE;
9263       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9264       const char *msg;
9265       unsigned long r_symndx;
9266       asection *sec;
9267       Elf_Internal_Shdr *symtab_hdr;
9268       struct elf_link_hash_entry *h;
9269       bfd_boolean rel_reloc;
9270
9271       rel_reloc = (NEWABI_P (input_bfd)
9272                    && mips_elf_rel_relocation_p (input_bfd, input_section,
9273                                                  relocs, rel));
9274       /* Find the relocation howto for this relocation.  */
9275       howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9276
9277       r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
9278       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9279       if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9280         {
9281           sec = local_sections[r_symndx];
9282           h = NULL;
9283         }
9284       else
9285         {
9286           unsigned long extsymoff;
9287
9288           extsymoff = 0;
9289           if (!elf_bad_symtab (input_bfd))
9290             extsymoff = symtab_hdr->sh_info;
9291           h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
9292           while (h->root.type == bfd_link_hash_indirect
9293                  || h->root.type == bfd_link_hash_warning)
9294             h = (struct elf_link_hash_entry *) h->root.u.i.link;
9295
9296           sec = NULL;
9297           if (h->root.type == bfd_link_hash_defined
9298               || h->root.type == bfd_link_hash_defweak)
9299             sec = h->root.u.def.section;
9300         }
9301
9302       if (sec != NULL && elf_discarded_section (sec))
9303         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9304                                          rel, relend, howto, contents);
9305
9306       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
9307         {
9308           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
9309              64-bit code, but make sure all their addresses are in the
9310              lowermost or uppermost 32-bit section of the 64-bit address
9311              space.  Thus, when they use an R_MIPS_64 they mean what is
9312              usually meant by R_MIPS_32, with the exception that the
9313              stored value is sign-extended to 64 bits.  */
9314           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
9315
9316           /* On big-endian systems, we need to lie about the position
9317              of the reloc.  */
9318           if (bfd_big_endian (input_bfd))
9319             rel->r_offset += 4;
9320         }
9321
9322       if (!use_saved_addend_p)
9323         {
9324           /* If these relocations were originally of the REL variety,
9325              we must pull the addend out of the field that will be
9326              relocated.  Otherwise, we simply use the contents of the
9327              RELA relocation.  */
9328           if (mips_elf_rel_relocation_p (input_bfd, input_section,
9329                                          relocs, rel))
9330             {
9331               rela_relocation_p = FALSE;
9332               addend = mips_elf_read_rel_addend (input_bfd, rel,
9333                                                  howto, contents);
9334               if (hi16_reloc_p (r_type)
9335                   || (got16_reloc_p (r_type)
9336                       && mips_elf_local_relocation_p (input_bfd, rel,
9337                                                       local_sections)))
9338                 {
9339                   if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
9340                                                      contents, &addend))
9341                     {
9342                       if (h)
9343                         name = h->root.root.string;
9344                       else
9345                         name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9346                                                  local_syms + r_symndx,
9347                                                  sec);
9348                       (*_bfd_error_handler)
9349                         (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9350                          input_bfd, input_section, name, howto->name,
9351                          rel->r_offset);
9352                     }
9353                 }
9354               else
9355                 addend <<= howto->rightshift;
9356             }
9357           else
9358             addend = rel->r_addend;
9359           mips_elf_adjust_addend (output_bfd, info, input_bfd,
9360                                   local_syms, local_sections, rel);
9361         }
9362
9363       if (info->relocatable)
9364         {
9365           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
9366               && bfd_big_endian (input_bfd))
9367             rel->r_offset -= 4;
9368
9369           if (!rela_relocation_p && rel->r_addend)
9370             {
9371               addend += rel->r_addend;
9372               if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
9373                 addend = mips_elf_high (addend);
9374               else if (r_type == R_MIPS_HIGHER)
9375                 addend = mips_elf_higher (addend);
9376               else if (r_type == R_MIPS_HIGHEST)
9377                 addend = mips_elf_highest (addend);
9378               else
9379                 addend >>= howto->rightshift;
9380
9381               /* We use the source mask, rather than the destination
9382                  mask because the place to which we are writing will be
9383                  source of the addend in the final link.  */
9384               addend &= howto->src_mask;
9385
9386               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9387                 /* See the comment above about using R_MIPS_64 in the 32-bit
9388                    ABI.  Here, we need to update the addend.  It would be
9389                    possible to get away with just using the R_MIPS_32 reloc
9390                    but for endianness.  */
9391                 {
9392                   bfd_vma sign_bits;
9393                   bfd_vma low_bits;
9394                   bfd_vma high_bits;
9395
9396                   if (addend & ((bfd_vma) 1 << 31))
9397 #ifdef BFD64
9398                     sign_bits = ((bfd_vma) 1 << 32) - 1;
9399 #else
9400                     sign_bits = -1;
9401 #endif
9402                   else
9403                     sign_bits = 0;
9404
9405                   /* If we don't know that we have a 64-bit type,
9406                      do two separate stores.  */
9407                   if (bfd_big_endian (input_bfd))
9408                     {
9409                       /* Store the sign-bits (which are most significant)
9410                          first.  */
9411                       low_bits = sign_bits;
9412                       high_bits = addend;
9413                     }
9414                   else
9415                     {
9416                       low_bits = addend;
9417                       high_bits = sign_bits;
9418                     }
9419                   bfd_put_32 (input_bfd, low_bits,
9420                               contents + rel->r_offset);
9421                   bfd_put_32 (input_bfd, high_bits,
9422                               contents + rel->r_offset + 4);
9423                   continue;
9424                 }
9425
9426               if (! mips_elf_perform_relocation (info, howto, rel, addend,
9427                                                  input_bfd, input_section,
9428                                                  contents, FALSE))
9429                 return FALSE;
9430             }
9431
9432           /* Go on to the next relocation.  */
9433           continue;
9434         }
9435
9436       /* In the N32 and 64-bit ABIs there may be multiple consecutive
9437          relocations for the same offset.  In that case we are
9438          supposed to treat the output of each relocation as the addend
9439          for the next.  */
9440       if (rel + 1 < relend
9441           && rel->r_offset == rel[1].r_offset
9442           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
9443         use_saved_addend_p = TRUE;
9444       else
9445         use_saved_addend_p = FALSE;
9446
9447       /* Figure out what value we are supposed to relocate.  */
9448       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
9449                                              input_section, info, rel,
9450                                              addend, howto, local_syms,
9451                                              local_sections, &value,
9452                                              &name, &cross_mode_jump_p,
9453                                              use_saved_addend_p))
9454         {
9455         case bfd_reloc_continue:
9456           /* There's nothing to do.  */
9457           continue;
9458
9459         case bfd_reloc_undefined:
9460           /* mips_elf_calculate_relocation already called the
9461              undefined_symbol callback.  There's no real point in
9462              trying to perform the relocation at this point, so we
9463              just skip ahead to the next relocation.  */
9464           continue;
9465
9466         case bfd_reloc_notsupported:
9467           msg = _("internal error: unsupported relocation error");
9468           info->callbacks->warning
9469             (info, msg, name, input_bfd, input_section, rel->r_offset);
9470           return FALSE;
9471
9472         case bfd_reloc_overflow:
9473           if (use_saved_addend_p)
9474             /* Ignore overflow until we reach the last relocation for
9475                a given location.  */
9476             ;
9477           else
9478             {
9479               struct mips_elf_link_hash_table *htab;
9480
9481               htab = mips_elf_hash_table (info);
9482               BFD_ASSERT (htab != NULL);
9483               BFD_ASSERT (name != NULL);
9484               if (!htab->small_data_overflow_reported
9485                   && (gprel16_reloc_p (howto->type)
9486                       || literal_reloc_p (howto->type)))
9487                 {
9488                   msg = _("small-data section exceeds 64KB;"
9489                           " lower small-data size limit (see option -G)");
9490
9491                   htab->small_data_overflow_reported = TRUE;
9492                   (*info->callbacks->einfo) ("%P: %s\n", msg);
9493                 }
9494               if (! ((*info->callbacks->reloc_overflow)
9495                      (info, NULL, name, howto->name, (bfd_vma) 0,
9496                       input_bfd, input_section, rel->r_offset)))
9497                 return FALSE;
9498             }
9499           break;
9500
9501         case bfd_reloc_ok:
9502           break;
9503
9504         case bfd_reloc_outofrange:
9505           if (jal_reloc_p (howto->type))
9506             {
9507               msg = _("JALX to a non-word-aligned address");
9508               info->callbacks->warning
9509                 (info, msg, name, input_bfd, input_section, rel->r_offset);
9510               return FALSE;
9511             }
9512           /* Fall through.  */
9513
9514         default:
9515           abort ();
9516           break;
9517         }
9518
9519       /* If we've got another relocation for the address, keep going
9520          until we reach the last one.  */
9521       if (use_saved_addend_p)
9522         {
9523           addend = value;
9524           continue;
9525         }
9526
9527       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9528         /* See the comment above about using R_MIPS_64 in the 32-bit
9529            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
9530            that calculated the right value.  Now, however, we
9531            sign-extend the 32-bit result to 64-bits, and store it as a
9532            64-bit value.  We are especially generous here in that we
9533            go to extreme lengths to support this usage on systems with
9534            only a 32-bit VMA.  */
9535         {
9536           bfd_vma sign_bits;
9537           bfd_vma low_bits;
9538           bfd_vma high_bits;
9539
9540           if (value & ((bfd_vma) 1 << 31))
9541 #ifdef BFD64
9542             sign_bits = ((bfd_vma) 1 << 32) - 1;
9543 #else
9544             sign_bits = -1;
9545 #endif
9546           else
9547             sign_bits = 0;
9548
9549           /* If we don't know that we have a 64-bit type,
9550              do two separate stores.  */
9551           if (bfd_big_endian (input_bfd))
9552             {
9553               /* Undo what we did above.  */
9554               rel->r_offset -= 4;
9555               /* Store the sign-bits (which are most significant)
9556                  first.  */
9557               low_bits = sign_bits;
9558               high_bits = value;
9559             }
9560           else
9561             {
9562               low_bits = value;
9563               high_bits = sign_bits;
9564             }
9565           bfd_put_32 (input_bfd, low_bits,
9566                       contents + rel->r_offset);
9567           bfd_put_32 (input_bfd, high_bits,
9568                       contents + rel->r_offset + 4);
9569           continue;
9570         }
9571
9572       /* Actually perform the relocation.  */
9573       if (! mips_elf_perform_relocation (info, howto, rel, value,
9574                                          input_bfd, input_section,
9575                                          contents, cross_mode_jump_p))
9576         return FALSE;
9577     }
9578
9579   return TRUE;
9580 }
9581 \f
9582 /* A function that iterates over each entry in la25_stubs and fills
9583    in the code for each one.  DATA points to a mips_htab_traverse_info.  */
9584
9585 static int
9586 mips_elf_create_la25_stub (void **slot, void *data)
9587 {
9588   struct mips_htab_traverse_info *hti;
9589   struct mips_elf_link_hash_table *htab;
9590   struct mips_elf_la25_stub *stub;
9591   asection *s;
9592   bfd_byte *loc;
9593   bfd_vma offset, target, target_high, target_low;
9594
9595   stub = (struct mips_elf_la25_stub *) *slot;
9596   hti = (struct mips_htab_traverse_info *) data;
9597   htab = mips_elf_hash_table (hti->info);
9598   BFD_ASSERT (htab != NULL);
9599
9600   /* Create the section contents, if we haven't already.  */
9601   s = stub->stub_section;
9602   loc = s->contents;
9603   if (loc == NULL)
9604     {
9605       loc = bfd_malloc (s->size);
9606       if (loc == NULL)
9607         {
9608           hti->error = TRUE;
9609           return FALSE;
9610         }
9611       s->contents = loc;
9612     }
9613
9614   /* Work out where in the section this stub should go.  */
9615   offset = stub->offset;
9616
9617   /* Work out the target address.  */
9618   target = (stub->h->root.root.u.def.section->output_section->vma
9619             + stub->h->root.root.u.def.section->output_offset
9620             + stub->h->root.root.u.def.value);
9621   target_high = ((target + 0x8000) >> 16) & 0xffff;
9622   target_low = (target & 0xffff);
9623
9624   if (stub->stub_section != htab->strampoline)
9625     {
9626       /* This is a simple LUI/ADDIU stub.  Zero out the beginning
9627          of the section and write the two instructions at the end.  */
9628       memset (loc, 0, offset);
9629       loc += offset;
9630       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9631         {
9632           bfd_put_16 (hti->output_bfd, LA25_LUI_MICROMIPS_1 (target_high),
9633                       loc);
9634           bfd_put_16 (hti->output_bfd, LA25_LUI_MICROMIPS_2 (target_high),
9635                       loc + 2);
9636           bfd_put_16 (hti->output_bfd, LA25_ADDIU_MICROMIPS_1 (target_low),
9637                       loc + 4);
9638           bfd_put_16 (hti->output_bfd, LA25_ADDIU_MICROMIPS_2 (target_low),
9639                       loc + 6);
9640         }
9641       else
9642         {
9643           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9644           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
9645         }
9646     }
9647   else
9648     {
9649       /* This is trampoline.  */
9650       loc += offset;
9651       if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9652         {
9653           bfd_put_16 (hti->output_bfd, LA25_LUI_MICROMIPS_1 (target_high),
9654                       loc);
9655           bfd_put_16 (hti->output_bfd, LA25_LUI_MICROMIPS_2 (target_high),
9656                       loc + 2);
9657           bfd_put_16 (hti->output_bfd, LA25_J_MICROMIPS_1 (target), loc + 4);
9658           bfd_put_16 (hti->output_bfd, LA25_J_MICROMIPS_2 (target), loc + 6);
9659           bfd_put_16 (hti->output_bfd, LA25_ADDIU_MICROMIPS_1 (target_low),
9660                       loc + 8);
9661           bfd_put_16 (hti->output_bfd, LA25_ADDIU_MICROMIPS_2 (target_low),
9662                       loc + 10);
9663           bfd_put_32 (hti->output_bfd, 0, loc + 12);
9664         }
9665       else
9666         {
9667           bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9668           bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
9669           bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
9670           bfd_put_32 (hti->output_bfd, 0, loc + 12);
9671         }
9672     }
9673   return TRUE;
9674 }
9675
9676 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9677    adjust it appropriately now.  */
9678
9679 static void
9680 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
9681                                       const char *name, Elf_Internal_Sym *sym)
9682 {
9683   /* The linker script takes care of providing names and values for
9684      these, but we must place them into the right sections.  */
9685   static const char* const text_section_symbols[] = {
9686     "_ftext",
9687     "_etext",
9688     "__dso_displacement",
9689     "__elf_header",
9690     "__program_header_table",
9691     NULL
9692   };
9693
9694   static const char* const data_section_symbols[] = {
9695     "_fdata",
9696     "_edata",
9697     "_end",
9698     "_fbss",
9699     NULL
9700   };
9701
9702   const char* const *p;
9703   int i;
9704
9705   for (i = 0; i < 2; ++i)
9706     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
9707          *p;
9708          ++p)
9709       if (strcmp (*p, name) == 0)
9710         {
9711           /* All of these symbols are given type STT_SECTION by the
9712              IRIX6 linker.  */
9713           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9714           sym->st_other = STO_PROTECTED;
9715
9716           /* The IRIX linker puts these symbols in special sections.  */
9717           if (i == 0)
9718             sym->st_shndx = SHN_MIPS_TEXT;
9719           else
9720             sym->st_shndx = SHN_MIPS_DATA;
9721
9722           break;
9723         }
9724 }
9725
9726 /* Finish up dynamic symbol handling.  We set the contents of various
9727    dynamic sections here.  */
9728
9729 bfd_boolean
9730 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
9731                                      struct bfd_link_info *info,
9732                                      struct elf_link_hash_entry *h,
9733                                      Elf_Internal_Sym *sym)
9734 {
9735   bfd *dynobj;
9736   asection *sgot;
9737   struct mips_got_info *g, *gg;
9738   const char *name;
9739   int idx;
9740   struct mips_elf_link_hash_table *htab;
9741   struct mips_elf_link_hash_entry *hmips;
9742
9743   htab = mips_elf_hash_table (info);
9744   BFD_ASSERT (htab != NULL);
9745   dynobj = elf_hash_table (info)->dynobj;
9746   hmips = (struct mips_elf_link_hash_entry *) h;
9747
9748   BFD_ASSERT (!htab->is_vxworks);
9749
9750   if (h->plt.offset != MINUS_ONE && hmips->no_fn_stub)
9751     {
9752       /* We've decided to create a PLT entry for this symbol.  */
9753       bfd_byte *loc;
9754       bfd_vma header_address, plt_index, got_address;
9755       bfd_vma got_address_high, got_address_low, load;
9756       const bfd_vma *plt_entry;
9757
9758       BFD_ASSERT (htab->use_plts_and_copy_relocs);
9759       BFD_ASSERT (h->dynindx != -1);
9760       BFD_ASSERT (htab->splt != NULL);
9761       BFD_ASSERT (h->plt.offset <= htab->splt->size);
9762       BFD_ASSERT (!h->def_regular);
9763
9764       /* Calculate the address of the PLT header.  */
9765       header_address = (htab->splt->output_section->vma
9766                         + htab->splt->output_offset);
9767
9768       /* Calculate the index of the entry.  */
9769       plt_index = ((h->plt.offset - htab->plt_header_size)
9770                    / htab->plt_entry_size);
9771
9772       /* Calculate the address of the .got.plt entry.  */
9773       got_address = (htab->sgotplt->output_section->vma
9774                      + htab->sgotplt->output_offset
9775                      + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9776       got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9777       got_address_low = got_address & 0xffff;
9778
9779       /* Initially point the .got.plt entry at the PLT header.  */
9780       loc = (htab->sgotplt->contents
9781              + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9782       if (ABI_64_P (output_bfd))
9783         bfd_put_64 (output_bfd, header_address, loc);
9784       else
9785         bfd_put_32 (output_bfd, header_address, loc);
9786
9787       /* Find out where the .plt entry should go.  */
9788       loc = htab->splt->contents + h->plt.offset;
9789
9790       /* Pick the load opcode.  */
9791       load = MIPS_ELF_LOAD_WORD (output_bfd);
9792
9793       /* Fill in the PLT entry itself.  */
9794       plt_entry = mips_exec_plt_entry;
9795       bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
9796       bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, loc + 4);
9797
9798       if (! LOAD_INTERLOCKS_P (output_bfd))
9799         {
9800           bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
9801           bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9802         }
9803       else
9804         {
9805           bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
9806           bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 12);
9807         }
9808
9809       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
9810       mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
9811                                           plt_index, h->dynindx,
9812                                           R_MIPS_JUMP_SLOT, got_address);
9813
9814       /* We distinguish between PLT entries and lazy-binding stubs by
9815          giving the former an st_other value of STO_MIPS_PLT.  Set the
9816          flag and leave the value if there are any relocations in the
9817          binary where pointer equality matters.  */
9818       sym->st_shndx = SHN_UNDEF;
9819       if (h->pointer_equality_needed)
9820         sym->st_other = STO_MIPS_PLT;
9821       else
9822         sym->st_value = 0;
9823     }
9824   else if (h->plt.offset != MINUS_ONE)
9825     {
9826       /* We've decided to create a lazy-binding stub.  */
9827       bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
9828
9829       /* This symbol has a stub.  Set it up.  */
9830
9831       BFD_ASSERT (h->dynindx != -1);
9832
9833       BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9834                   || (h->dynindx <= 0xffff));
9835
9836       /* Values up to 2^31 - 1 are allowed.  Larger values would cause
9837          sign extension at runtime in the stub, resulting in a negative
9838          index value.  */
9839       if (h->dynindx & ~0x7fffffff)
9840         return FALSE;
9841
9842       /* Fill the stub.  */
9843       idx = 0;
9844       bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
9845       idx += 4;
9846       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
9847       idx += 4;
9848       if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9849         {
9850           bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
9851                       stub + idx);
9852           idx += 4;
9853         }
9854       bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
9855       idx += 4;
9856
9857       /* If a large stub is not required and sign extension is not a
9858          problem, then use legacy code in the stub.  */
9859       if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9860         bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
9861       else if (h->dynindx & ~0x7fff)
9862         bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
9863       else
9864         bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
9865                     stub + idx);
9866
9867       BFD_ASSERT (h->plt.offset <= htab->sstubs->size);
9868       memcpy (htab->sstubs->contents + h->plt.offset,
9869               stub, htab->function_stub_size);
9870
9871       /* Mark the symbol as undefined.  plt.offset != -1 occurs
9872          only for the referenced symbol.  */
9873       sym->st_shndx = SHN_UNDEF;
9874
9875       /* The run-time linker uses the st_value field of the symbol
9876          to reset the global offset table entry for this external
9877          to its stub address when unlinking a shared object.  */
9878       sym->st_value = (htab->sstubs->output_section->vma
9879                        + htab->sstubs->output_offset
9880                        + h->plt.offset);
9881     }
9882
9883   /* If we have a MIPS16 function with a stub, the dynamic symbol must
9884      refer to the stub, since only the stub uses the standard calling
9885      conventions.  */
9886   if (h->dynindx != -1 && hmips->fn_stub != NULL)
9887     {
9888       BFD_ASSERT (hmips->need_fn_stub);
9889       sym->st_value = (hmips->fn_stub->output_section->vma
9890                        + hmips->fn_stub->output_offset);
9891       sym->st_size = hmips->fn_stub->size;
9892       sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
9893     }
9894
9895   BFD_ASSERT (h->dynindx != -1
9896               || h->forced_local);
9897
9898   sgot = htab->sgot;
9899   g = htab->got_info;
9900   BFD_ASSERT (g != NULL);
9901
9902   /* Run through the global symbol table, creating GOT entries for all
9903      the symbols that need them.  */
9904   if (hmips->global_got_area != GGA_NONE)
9905     {
9906       bfd_vma offset;
9907       bfd_vma value;
9908
9909       value = sym->st_value;
9910       offset = mips_elf_global_got_index (dynobj, output_bfd, h,
9911                                           R_MIPS_GOT16, info);
9912       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
9913     }
9914
9915   if (hmips->global_got_area != GGA_NONE && g->next && h->type != STT_TLS)
9916     {
9917       struct mips_got_entry e, *p;
9918       bfd_vma entry;
9919       bfd_vma offset;
9920
9921       gg = g;
9922
9923       e.abfd = output_bfd;
9924       e.symndx = -1;
9925       e.d.h = hmips;
9926       e.tls_type = 0;
9927
9928       for (g = g->next; g->next != gg; g = g->next)
9929         {
9930           if (g->got_entries
9931               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
9932                                                            &e)))
9933             {
9934               offset = p->gotidx;
9935               if (info->shared
9936                   || (elf_hash_table (info)->dynamic_sections_created
9937                       && p->d.h != NULL
9938                       && p->d.h->root.def_dynamic
9939                       && !p->d.h->root.def_regular))
9940                 {
9941                   /* Create an R_MIPS_REL32 relocation for this entry.  Due to
9942                      the various compatibility problems, it's easier to mock
9943                      up an R_MIPS_32 or R_MIPS_64 relocation and leave
9944                      mips_elf_create_dynamic_relocation to calculate the
9945                      appropriate addend.  */
9946                   Elf_Internal_Rela rel[3];
9947
9948                   memset (rel, 0, sizeof (rel));
9949                   if (ABI_64_P (output_bfd))
9950                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
9951                   else
9952                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
9953                   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
9954
9955                   entry = 0;
9956                   if (! (mips_elf_create_dynamic_relocation
9957                          (output_bfd, info, rel,
9958                           e.d.h, NULL, sym->st_value, &entry, sgot)))
9959                     return FALSE;
9960                 }
9961               else
9962                 entry = sym->st_value;
9963               MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
9964             }
9965         }
9966     }
9967
9968   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
9969   name = h->root.root.string;
9970   if (strcmp (name, "_DYNAMIC") == 0
9971       || h == elf_hash_table (info)->hgot)
9972     sym->st_shndx = SHN_ABS;
9973   else if (strcmp (name, "_DYNAMIC_LINK") == 0
9974            || strcmp (name, "_DYNAMIC_LINKING") == 0)
9975     {
9976       sym->st_shndx = SHN_ABS;
9977       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9978       sym->st_value = 1;
9979     }
9980   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
9981     {
9982       sym->st_shndx = SHN_ABS;
9983       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9984       sym->st_value = elf_gp (output_bfd);
9985     }
9986   else if (SGI_COMPAT (output_bfd))
9987     {
9988       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
9989           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
9990         {
9991           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9992           sym->st_other = STO_PROTECTED;
9993           sym->st_value = 0;
9994           sym->st_shndx = SHN_MIPS_DATA;
9995         }
9996       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
9997         {
9998           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9999           sym->st_other = STO_PROTECTED;
10000           sym->st_value = mips_elf_hash_table (info)->procedure_count;
10001           sym->st_shndx = SHN_ABS;
10002         }
10003       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
10004         {
10005           if (h->type == STT_FUNC)
10006             sym->st_shndx = SHN_MIPS_TEXT;
10007           else if (h->type == STT_OBJECT)
10008             sym->st_shndx = SHN_MIPS_DATA;
10009         }
10010     }
10011
10012   /* Emit a copy reloc, if needed.  */
10013   if (h->needs_copy)
10014     {
10015       asection *s;
10016       bfd_vma symval;
10017
10018       BFD_ASSERT (h->dynindx != -1);
10019       BFD_ASSERT (htab->use_plts_and_copy_relocs);
10020
10021       s = mips_elf_rel_dyn_section (info, FALSE);
10022       symval = (h->root.u.def.section->output_section->vma
10023                 + h->root.u.def.section->output_offset
10024                 + h->root.u.def.value);
10025       mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
10026                                           h->dynindx, R_MIPS_COPY, symval);
10027     }
10028
10029   /* Handle the IRIX6-specific symbols.  */
10030   if (IRIX_COMPAT (output_bfd) == ict_irix6)
10031     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
10032
10033   if (! info->shared)
10034     {
10035       if (! mips_elf_hash_table (info)->use_rld_obj_head
10036           && (strcmp (name, "__rld_map") == 0
10037               || strcmp (name, "__RLD_MAP") == 0))
10038         {
10039           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
10040           BFD_ASSERT (s != NULL);
10041           sym->st_value = s->output_section->vma + s->output_offset;
10042           bfd_put_32 (output_bfd, 0, s->contents);
10043           if (mips_elf_hash_table (info)->rld_value == 0)
10044             mips_elf_hash_table (info)->rld_value = sym->st_value;
10045         }
10046       else if (mips_elf_hash_table (info)->use_rld_obj_head
10047                && strcmp (name, "__rld_obj_head") == 0)
10048         {
10049           /* IRIX6 does not use a .rld_map section.  */
10050           if (IRIX_COMPAT (output_bfd) == ict_irix5
10051               || IRIX_COMPAT (output_bfd) == ict_none)
10052             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
10053                         != NULL);
10054           mips_elf_hash_table (info)->rld_value = sym->st_value;
10055         }
10056     }
10057
10058   /* Keep dynamic MIPS16 symbols odd.  This allows the dynamic linker to
10059      treat MIPS16 symbols like any other.  */
10060   if (ELF_ST_IS_MIPS16 (sym->st_other))
10061     {
10062       BFD_ASSERT (sym->st_value & 1);
10063       sym->st_other -= STO_MIPS16;
10064     }
10065
10066   return TRUE;
10067 }
10068
10069 /* Likewise, for VxWorks.  */
10070
10071 bfd_boolean
10072 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
10073                                          struct bfd_link_info *info,
10074                                          struct elf_link_hash_entry *h,
10075                                          Elf_Internal_Sym *sym)
10076 {
10077   bfd *dynobj;
10078   asection *sgot;
10079   struct mips_got_info *g;
10080   struct mips_elf_link_hash_table *htab;
10081   struct mips_elf_link_hash_entry *hmips;
10082
10083   htab = mips_elf_hash_table (info);
10084   BFD_ASSERT (htab != NULL);
10085   dynobj = elf_hash_table (info)->dynobj;
10086   hmips = (struct mips_elf_link_hash_entry *) h;
10087
10088   if (h->plt.offset != (bfd_vma) -1)
10089     {
10090       bfd_byte *loc;
10091       bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
10092       Elf_Internal_Rela rel;
10093       static const bfd_vma *plt_entry;
10094
10095       BFD_ASSERT (h->dynindx != -1);
10096       BFD_ASSERT (htab->splt != NULL);
10097       BFD_ASSERT (h->plt.offset <= htab->splt->size);
10098
10099       /* Calculate the address of the .plt entry.  */
10100       plt_address = (htab->splt->output_section->vma
10101                      + htab->splt->output_offset
10102                      + h->plt.offset);
10103
10104       /* Calculate the index of the entry.  */
10105       plt_index = ((h->plt.offset - htab->plt_header_size)
10106                    / htab->plt_entry_size);
10107
10108       /* Calculate the address of the .got.plt entry.  */
10109       got_address = (htab->sgotplt->output_section->vma
10110                      + htab->sgotplt->output_offset
10111                      + plt_index * 4);
10112
10113       /* Calculate the offset of the .got.plt entry from
10114          _GLOBAL_OFFSET_TABLE_.  */
10115       got_offset = mips_elf_gotplt_index (info, h);
10116
10117       /* Calculate the offset for the branch at the start of the PLT
10118          entry.  The branch jumps to the beginning of .plt.  */
10119       branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
10120
10121       /* Fill in the initial value of the .got.plt entry.  */
10122       bfd_put_32 (output_bfd, plt_address,
10123                   htab->sgotplt->contents + plt_index * 4);
10124
10125       /* Find out where the .plt entry should go.  */
10126       loc = htab->splt->contents + h->plt.offset;
10127
10128       if (info->shared)
10129         {
10130           plt_entry = mips_vxworks_shared_plt_entry;
10131           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10132           bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10133         }
10134       else
10135         {
10136           bfd_vma got_address_high, got_address_low;
10137
10138           plt_entry = mips_vxworks_exec_plt_entry;
10139           got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10140           got_address_low = got_address & 0xffff;
10141
10142           bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10143           bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10144           bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
10145           bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
10146           bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10147           bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10148           bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10149           bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10150
10151           loc = (htab->srelplt2->contents
10152                  + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
10153
10154           /* Emit a relocation for the .got.plt entry.  */
10155           rel.r_offset = got_address;
10156           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10157           rel.r_addend = h->plt.offset;
10158           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10159
10160           /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
10161           loc += sizeof (Elf32_External_Rela);
10162           rel.r_offset = plt_address + 8;
10163           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10164           rel.r_addend = got_offset;
10165           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10166
10167           /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
10168           loc += sizeof (Elf32_External_Rela);
10169           rel.r_offset += 4;
10170           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10171           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10172         }
10173
10174       /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
10175       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
10176       rel.r_offset = got_address;
10177       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
10178       rel.r_addend = 0;
10179       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10180
10181       if (!h->def_regular)
10182         sym->st_shndx = SHN_UNDEF;
10183     }
10184
10185   BFD_ASSERT (h->dynindx != -1 || h->forced_local);
10186
10187   sgot = htab->sgot;
10188   g = htab->got_info;
10189   BFD_ASSERT (g != NULL);
10190
10191   /* See if this symbol has an entry in the GOT.  */
10192   if (hmips->global_got_area != GGA_NONE)
10193     {
10194       bfd_vma offset;
10195       Elf_Internal_Rela outrel;
10196       bfd_byte *loc;
10197       asection *s;
10198
10199       /* Install the symbol value in the GOT.   */
10200       offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10201                                           R_MIPS_GOT16, info);
10202       MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
10203
10204       /* Add a dynamic relocation for it.  */
10205       s = mips_elf_rel_dyn_section (info, FALSE);
10206       loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
10207       outrel.r_offset = (sgot->output_section->vma
10208                          + sgot->output_offset
10209                          + offset);
10210       outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
10211       outrel.r_addend = 0;
10212       bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
10213     }
10214
10215   /* Emit a copy reloc, if needed.  */
10216   if (h->needs_copy)
10217     {
10218       Elf_Internal_Rela rel;
10219
10220       BFD_ASSERT (h->dynindx != -1);
10221
10222       rel.r_offset = (h->root.u.def.section->output_section->vma
10223                       + h->root.u.def.section->output_offset
10224                       + h->root.u.def.value);
10225       rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
10226       rel.r_addend = 0;
10227       bfd_elf32_swap_reloca_out (output_bfd, &rel,
10228                                  htab->srelbss->contents
10229                                  + (htab->srelbss->reloc_count
10230                                     * sizeof (Elf32_External_Rela)));
10231       ++htab->srelbss->reloc_count;
10232     }
10233
10234   /* If this is a mips16/microMIPS symbol, force the value to be even.  */
10235   if (ELF_ST_IS_COMPRESSED (sym->st_other))
10236     sym->st_value &= ~1;
10237
10238   return TRUE;
10239 }
10240
10241 /* Write out a plt0 entry to the beginning of .plt.  */
10242
10243 static void
10244 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10245 {
10246   bfd_byte *loc;
10247   bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
10248   static const bfd_vma *plt_entry;
10249   struct mips_elf_link_hash_table *htab;
10250
10251   htab = mips_elf_hash_table (info);
10252   BFD_ASSERT (htab != NULL);
10253
10254   if (ABI_64_P (output_bfd))
10255     plt_entry = mips_n64_exec_plt0_entry;
10256   else if (ABI_N32_P (output_bfd))
10257     plt_entry = mips_n32_exec_plt0_entry;
10258   else
10259     plt_entry = mips_o32_exec_plt0_entry;
10260
10261   /* Calculate the value of .got.plt.  */
10262   gotplt_value = (htab->sgotplt->output_section->vma
10263                   + htab->sgotplt->output_offset);
10264   gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
10265   gotplt_value_low = gotplt_value & 0xffff;
10266
10267   /* The PLT sequence is not safe for N64 if .got.plt's address can
10268      not be loaded in two instructions.  */
10269   BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
10270               || ~(gotplt_value | 0x7fffffff) == 0);
10271
10272   /* Install the PLT header.  */
10273   loc = htab->splt->contents;
10274   bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
10275   bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
10276   bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
10277   bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10278   bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10279   bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10280   bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10281   bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10282 }
10283
10284 /* Install the PLT header for a VxWorks executable and finalize the
10285    contents of .rela.plt.unloaded.  */
10286
10287 static void
10288 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10289 {
10290   Elf_Internal_Rela rela;
10291   bfd_byte *loc;
10292   bfd_vma got_value, got_value_high, got_value_low, plt_address;
10293   static const bfd_vma *plt_entry;
10294   struct mips_elf_link_hash_table *htab;
10295
10296   htab = mips_elf_hash_table (info);
10297   BFD_ASSERT (htab != NULL);
10298
10299   plt_entry = mips_vxworks_exec_plt0_entry;
10300
10301   /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
10302   got_value = (htab->root.hgot->root.u.def.section->output_section->vma
10303                + htab->root.hgot->root.u.def.section->output_offset
10304                + htab->root.hgot->root.u.def.value);
10305
10306   got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
10307   got_value_low = got_value & 0xffff;
10308
10309   /* Calculate the address of the PLT header.  */
10310   plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
10311
10312   /* Install the PLT header.  */
10313   loc = htab->splt->contents;
10314   bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
10315   bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
10316   bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
10317   bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10318   bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10319   bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10320
10321   /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
10322   loc = htab->srelplt2->contents;
10323   rela.r_offset = plt_address;
10324   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10325   rela.r_addend = 0;
10326   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10327   loc += sizeof (Elf32_External_Rela);
10328
10329   /* Output the relocation for the following addiu of
10330      %lo(_GLOBAL_OFFSET_TABLE_).  */
10331   rela.r_offset += 4;
10332   rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10333   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10334   loc += sizeof (Elf32_External_Rela);
10335
10336   /* Fix up the remaining relocations.  They may have the wrong
10337      symbol index for _G_O_T_ or _P_L_T_ depending on the order
10338      in which symbols were output.  */
10339   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10340     {
10341       Elf_Internal_Rela rel;
10342
10343       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10344       rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10345       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10346       loc += sizeof (Elf32_External_Rela);
10347
10348       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10349       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10350       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10351       loc += sizeof (Elf32_External_Rela);
10352
10353       bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10354       rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10355       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10356       loc += sizeof (Elf32_External_Rela);
10357     }
10358 }
10359
10360 /* Install the PLT header for a VxWorks shared library.  */
10361
10362 static void
10363 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
10364 {
10365   unsigned int i;
10366   struct mips_elf_link_hash_table *htab;
10367
10368   htab = mips_elf_hash_table (info);
10369   BFD_ASSERT (htab != NULL);
10370
10371   /* We just need to copy the entry byte-by-byte.  */
10372   for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
10373     bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
10374                 htab->splt->contents + i * 4);
10375 }
10376
10377 /* Finish up the dynamic sections.  */
10378
10379 bfd_boolean
10380 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
10381                                        struct bfd_link_info *info)
10382 {
10383   bfd *dynobj;
10384   asection *sdyn;
10385   asection *sgot;
10386   struct mips_got_info *gg, *g;
10387   struct mips_elf_link_hash_table *htab;
10388
10389   htab = mips_elf_hash_table (info);
10390   BFD_ASSERT (htab != NULL);
10391
10392   dynobj = elf_hash_table (info)->dynobj;
10393
10394   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
10395
10396   sgot = htab->sgot;
10397   gg = htab->got_info;
10398
10399   if (elf_hash_table (info)->dynamic_sections_created)
10400     {
10401       bfd_byte *b;
10402       int dyn_to_skip = 0, dyn_skipped = 0;
10403
10404       BFD_ASSERT (sdyn != NULL);
10405       BFD_ASSERT (gg != NULL);
10406
10407       g = mips_elf_got_for_ibfd (gg, output_bfd);
10408       BFD_ASSERT (g != NULL);
10409
10410       for (b = sdyn->contents;
10411            b < sdyn->contents + sdyn->size;
10412            b += MIPS_ELF_DYN_SIZE (dynobj))
10413         {
10414           Elf_Internal_Dyn dyn;
10415           const char *name;
10416           size_t elemsize;
10417           asection *s;
10418           bfd_boolean swap_out_p;
10419
10420           /* Read in the current dynamic entry.  */
10421           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10422
10423           /* Assume that we're going to modify it and write it out.  */
10424           swap_out_p = TRUE;
10425
10426           switch (dyn.d_tag)
10427             {
10428             case DT_RELENT:
10429               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
10430               break;
10431
10432             case DT_RELAENT:
10433               BFD_ASSERT (htab->is_vxworks);
10434               dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
10435               break;
10436
10437             case DT_STRSZ:
10438               /* Rewrite DT_STRSZ.  */
10439               dyn.d_un.d_val =
10440                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
10441               break;
10442
10443             case DT_PLTGOT:
10444               s = htab->sgot;
10445               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10446               break;
10447
10448             case DT_MIPS_PLTGOT:
10449               s = htab->sgotplt;
10450               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10451               break;
10452
10453             case DT_MIPS_RLD_VERSION:
10454               dyn.d_un.d_val = 1; /* XXX */
10455               break;
10456
10457             case DT_MIPS_FLAGS:
10458               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
10459               break;
10460
10461             case DT_MIPS_TIME_STAMP:
10462               {
10463                 time_t t;
10464                 time (&t);
10465                 dyn.d_un.d_val = t;
10466               }
10467               break;
10468
10469             case DT_MIPS_ICHECKSUM:
10470               /* XXX FIXME: */
10471               swap_out_p = FALSE;
10472               break;
10473
10474             case DT_MIPS_IVERSION:
10475               /* XXX FIXME: */
10476               swap_out_p = FALSE;
10477               break;
10478
10479             case DT_MIPS_BASE_ADDRESS:
10480               s = output_bfd->sections;
10481               BFD_ASSERT (s != NULL);
10482               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
10483               break;
10484
10485             case DT_MIPS_LOCAL_GOTNO:
10486               dyn.d_un.d_val = g->local_gotno;
10487               break;
10488
10489             case DT_MIPS_UNREFEXTNO:
10490               /* The index into the dynamic symbol table which is the
10491                  entry of the first external symbol that is not
10492                  referenced within the same object.  */
10493               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
10494               break;
10495
10496             case DT_MIPS_GOTSYM:
10497               if (gg->global_gotsym)
10498                 {
10499                   dyn.d_un.d_val = gg->global_gotsym->dynindx;
10500                   break;
10501                 }
10502               /* In case if we don't have global got symbols we default
10503                  to setting DT_MIPS_GOTSYM to the same value as
10504                  DT_MIPS_SYMTABNO, so we just fall through.  */
10505
10506             case DT_MIPS_SYMTABNO:
10507               name = ".dynsym";
10508               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
10509               s = bfd_get_section_by_name (output_bfd, name);
10510               BFD_ASSERT (s != NULL);
10511
10512               dyn.d_un.d_val = s->size / elemsize;
10513               break;
10514
10515             case DT_MIPS_HIPAGENO:
10516               dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
10517               break;
10518
10519             case DT_MIPS_RLD_MAP:
10520               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
10521               break;
10522
10523             case DT_MIPS_OPTIONS:
10524               s = (bfd_get_section_by_name
10525                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
10526               dyn.d_un.d_ptr = s->vma;
10527               break;
10528
10529             case DT_RELASZ:
10530               BFD_ASSERT (htab->is_vxworks);
10531               /* The count does not include the JUMP_SLOT relocations.  */
10532               if (htab->srelplt)
10533                 dyn.d_un.d_val -= htab->srelplt->size;
10534               break;
10535
10536             case DT_PLTREL:
10537               BFD_ASSERT (htab->use_plts_and_copy_relocs);
10538               if (htab->is_vxworks)
10539                 dyn.d_un.d_val = DT_RELA;
10540               else
10541                 dyn.d_un.d_val = DT_REL;
10542               break;
10543
10544             case DT_PLTRELSZ:
10545               BFD_ASSERT (htab->use_plts_and_copy_relocs);
10546               dyn.d_un.d_val = htab->srelplt->size;
10547               break;
10548
10549             case DT_JMPREL:
10550               BFD_ASSERT (htab->use_plts_and_copy_relocs);
10551               dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
10552                                 + htab->srelplt->output_offset);
10553               break;
10554
10555             case DT_TEXTREL:
10556               /* If we didn't need any text relocations after all, delete
10557                  the dynamic tag.  */
10558               if (!(info->flags & DF_TEXTREL))
10559                 {
10560                   dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10561                   swap_out_p = FALSE;
10562                 }
10563               break;
10564
10565             case DT_FLAGS:
10566               /* If we didn't need any text relocations after all, clear
10567                  DF_TEXTREL from DT_FLAGS.  */
10568               if (!(info->flags & DF_TEXTREL))
10569                 dyn.d_un.d_val &= ~DF_TEXTREL;
10570               else
10571                 swap_out_p = FALSE;
10572               break;
10573
10574             default:
10575               swap_out_p = FALSE;
10576               if (htab->is_vxworks
10577                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10578                 swap_out_p = TRUE;
10579               break;
10580             }
10581
10582           if (swap_out_p || dyn_skipped)
10583             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10584               (dynobj, &dyn, b - dyn_skipped);
10585
10586           if (dyn_to_skip)
10587             {
10588               dyn_skipped += dyn_to_skip;
10589               dyn_to_skip = 0;
10590             }
10591         }
10592
10593       /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
10594       if (dyn_skipped > 0)
10595         memset (b - dyn_skipped, 0, dyn_skipped);
10596     }
10597
10598   if (sgot != NULL && sgot->size > 0
10599       && !bfd_is_abs_section (sgot->output_section))
10600     {
10601       if (htab->is_vxworks)
10602         {
10603           /* The first entry of the global offset table points to the
10604              ".dynamic" section.  The second is initialized by the
10605              loader and contains the shared library identifier.
10606              The third is also initialized by the loader and points
10607              to the lazy resolution stub.  */
10608           MIPS_ELF_PUT_WORD (output_bfd,
10609                              sdyn->output_offset + sdyn->output_section->vma,
10610                              sgot->contents);
10611           MIPS_ELF_PUT_WORD (output_bfd, 0,
10612                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10613           MIPS_ELF_PUT_WORD (output_bfd, 0,
10614                              sgot->contents
10615                              + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
10616         }
10617       else
10618         {
10619           /* The first entry of the global offset table will be filled at
10620              runtime. The second entry will be used by some runtime loaders.
10621              This isn't the case of IRIX rld.  */
10622           MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
10623           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10624                              sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10625         }
10626
10627       elf_section_data (sgot->output_section)->this_hdr.sh_entsize
10628          = MIPS_ELF_GOT_SIZE (output_bfd);
10629     }
10630
10631   /* Generate dynamic relocations for the non-primary gots.  */
10632   if (gg != NULL && gg->next)
10633     {
10634       Elf_Internal_Rela rel[3];
10635       bfd_vma addend = 0;
10636
10637       memset (rel, 0, sizeof (rel));
10638       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
10639
10640       for (g = gg->next; g->next != gg; g = g->next)
10641         {
10642           bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
10643             + g->next->tls_gotno;
10644
10645           MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
10646                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10647           MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10648                              sgot->contents
10649                              + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10650
10651           if (! info->shared)
10652             continue;
10653
10654           while (got_index < g->assigned_gotno)
10655             {
10656               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
10657                 = got_index++ * MIPS_ELF_GOT_SIZE (output_bfd);
10658               if (!(mips_elf_create_dynamic_relocation
10659                     (output_bfd, info, rel, NULL,
10660                      bfd_abs_section_ptr,
10661                      0, &addend, sgot)))
10662                 return FALSE;
10663               BFD_ASSERT (addend == 0);
10664             }
10665         }
10666     }
10667
10668   /* The generation of dynamic relocations for the non-primary gots
10669      adds more dynamic relocations.  We cannot count them until
10670      here.  */
10671
10672   if (elf_hash_table (info)->dynamic_sections_created)
10673     {
10674       bfd_byte *b;
10675       bfd_boolean swap_out_p;
10676
10677       BFD_ASSERT (sdyn != NULL);
10678
10679       for (b = sdyn->contents;
10680            b < sdyn->contents + sdyn->size;
10681            b += MIPS_ELF_DYN_SIZE (dynobj))
10682         {
10683           Elf_Internal_Dyn dyn;
10684           asection *s;
10685
10686           /* Read in the current dynamic entry.  */
10687           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10688
10689           /* Assume that we're going to modify it and write it out.  */
10690           swap_out_p = TRUE;
10691
10692           switch (dyn.d_tag)
10693             {
10694             case DT_RELSZ:
10695               /* Reduce DT_RELSZ to account for any relocations we
10696                  decided not to make.  This is for the n64 irix rld,
10697                  which doesn't seem to apply any relocations if there
10698                  are trailing null entries.  */
10699               s = mips_elf_rel_dyn_section (info, FALSE);
10700               dyn.d_un.d_val = (s->reloc_count
10701                                 * (ABI_64_P (output_bfd)
10702                                    ? sizeof (Elf64_Mips_External_Rel)
10703                                    : sizeof (Elf32_External_Rel)));
10704               /* Adjust the section size too.  Tools like the prelinker
10705                  can reasonably expect the values to the same.  */
10706               elf_section_data (s->output_section)->this_hdr.sh_size
10707                 = dyn.d_un.d_val;
10708               break;
10709
10710             default:
10711               swap_out_p = FALSE;
10712               break;
10713             }
10714
10715           if (swap_out_p)
10716             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10717               (dynobj, &dyn, b);
10718         }
10719     }
10720
10721   {
10722     asection *s;
10723     Elf32_compact_rel cpt;
10724
10725     if (SGI_COMPAT (output_bfd))
10726       {
10727         /* Write .compact_rel section out.  */
10728         s = bfd_get_section_by_name (dynobj, ".compact_rel");
10729         if (s != NULL)
10730           {
10731             cpt.id1 = 1;
10732             cpt.num = s->reloc_count;
10733             cpt.id2 = 2;
10734             cpt.offset = (s->output_section->filepos
10735                           + sizeof (Elf32_External_compact_rel));
10736             cpt.reserved0 = 0;
10737             cpt.reserved1 = 0;
10738             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
10739                                             ((Elf32_External_compact_rel *)
10740                                              s->contents));
10741
10742             /* Clean up a dummy stub function entry in .text.  */
10743             if (htab->sstubs != NULL)
10744               {
10745                 file_ptr dummy_offset;
10746
10747                 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
10748                 dummy_offset = htab->sstubs->size - htab->function_stub_size;
10749                 memset (htab->sstubs->contents + dummy_offset, 0,
10750                         htab->function_stub_size);
10751               }
10752           }
10753       }
10754
10755     /* The psABI says that the dynamic relocations must be sorted in
10756        increasing order of r_symndx.  The VxWorks EABI doesn't require
10757        this, and because the code below handles REL rather than RELA
10758        relocations, using it for VxWorks would be outright harmful.  */
10759     if (!htab->is_vxworks)
10760       {
10761         s = mips_elf_rel_dyn_section (info, FALSE);
10762         if (s != NULL
10763             && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
10764           {
10765             reldyn_sorting_bfd = output_bfd;
10766
10767             if (ABI_64_P (output_bfd))
10768               qsort ((Elf64_External_Rel *) s->contents + 1,
10769                      s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
10770                      sort_dynamic_relocs_64);
10771             else
10772               qsort ((Elf32_External_Rel *) s->contents + 1,
10773                      s->reloc_count - 1, sizeof (Elf32_External_Rel),
10774                      sort_dynamic_relocs);
10775           }
10776       }
10777   }
10778
10779   if (htab->splt && htab->splt->size > 0)
10780     {
10781       if (htab->is_vxworks)
10782         {
10783           if (info->shared)
10784             mips_vxworks_finish_shared_plt (output_bfd, info);
10785           else
10786             mips_vxworks_finish_exec_plt (output_bfd, info);
10787         }
10788       else
10789         {
10790           BFD_ASSERT (!info->shared);
10791           mips_finish_exec_plt (output_bfd, info);
10792         }
10793     }
10794   return TRUE;
10795 }
10796
10797
10798 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
10799
10800 static void
10801 mips_set_isa_flags (bfd *abfd)
10802 {
10803   flagword val;
10804
10805   switch (bfd_get_mach (abfd))
10806     {
10807     default:
10808     case bfd_mach_mips3000:
10809       val = E_MIPS_ARCH_1;
10810       break;
10811
10812     case bfd_mach_mips3900:
10813       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
10814       break;
10815
10816     case bfd_mach_mips6000:
10817       val = E_MIPS_ARCH_2;
10818       break;
10819
10820     case bfd_mach_mips4000:
10821     case bfd_mach_mips4300:
10822     case bfd_mach_mips4400:
10823     case bfd_mach_mips4600:
10824       val = E_MIPS_ARCH_3;
10825       break;
10826
10827     case bfd_mach_mips4010:
10828       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
10829       break;
10830
10831     case bfd_mach_mips4100:
10832       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
10833       break;
10834
10835     case bfd_mach_mips4111:
10836       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
10837       break;
10838
10839     case bfd_mach_mips4120:
10840       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
10841       break;
10842
10843     case bfd_mach_mips4650:
10844       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
10845       break;
10846
10847     case bfd_mach_mips5400:
10848       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
10849       break;
10850
10851     case bfd_mach_mips5500:
10852       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
10853       break;
10854
10855     case bfd_mach_mips9000:
10856       val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
10857       break;
10858
10859     case bfd_mach_mips5000:
10860     case bfd_mach_mips7000:
10861     case bfd_mach_mips8000:
10862     case bfd_mach_mips10000:
10863     case bfd_mach_mips12000:
10864     case bfd_mach_mips14000:
10865     case bfd_mach_mips16000:
10866       val = E_MIPS_ARCH_4;
10867       break;
10868
10869     case bfd_mach_mips5:
10870       val = E_MIPS_ARCH_5;
10871       break;
10872
10873     case bfd_mach_mips_loongson_2e:
10874       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
10875       break;
10876
10877     case bfd_mach_mips_loongson_2f:
10878       val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
10879       break;
10880
10881     case bfd_mach_mips_sb1:
10882       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
10883       break;
10884
10885     case bfd_mach_mips_loongson_3a:
10886       val = E_MIPS_ARCH_64 | E_MIPS_MACH_LS3A;
10887       break;
10888
10889     case bfd_mach_mips_octeon:
10890       val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
10891       break;
10892
10893     case bfd_mach_mips_xlr:
10894       val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
10895       break;
10896
10897     case bfd_mach_mipsisa32:
10898       val = E_MIPS_ARCH_32;
10899       break;
10900
10901     case bfd_mach_mipsisa64:
10902       val = E_MIPS_ARCH_64;
10903       break;
10904
10905     case bfd_mach_mipsisa32r2:
10906       val = E_MIPS_ARCH_32R2;
10907       break;
10908
10909     case bfd_mach_mipsisa64r2:
10910       val = E_MIPS_ARCH_64R2;
10911       break;
10912     }
10913   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
10914   elf_elfheader (abfd)->e_flags |= val;
10915
10916 }
10917
10918
10919 /* The final processing done just before writing out a MIPS ELF object
10920    file.  This gets the MIPS architecture right based on the machine
10921    number.  This is used by both the 32-bit and the 64-bit ABI.  */
10922
10923 void
10924 _bfd_mips_elf_final_write_processing (bfd *abfd,
10925                                       bfd_boolean linker ATTRIBUTE_UNUSED)
10926 {
10927   unsigned int i;
10928   Elf_Internal_Shdr **hdrpp;
10929   const char *name;
10930   asection *sec;
10931
10932   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
10933      is nonzero.  This is for compatibility with old objects, which used
10934      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
10935   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
10936     mips_set_isa_flags (abfd);
10937
10938   /* Set the sh_info field for .gptab sections and other appropriate
10939      info for each special section.  */
10940   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
10941        i < elf_numsections (abfd);
10942        i++, hdrpp++)
10943     {
10944       switch ((*hdrpp)->sh_type)
10945         {
10946         case SHT_MIPS_MSYM:
10947         case SHT_MIPS_LIBLIST:
10948           sec = bfd_get_section_by_name (abfd, ".dynstr");
10949           if (sec != NULL)
10950             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10951           break;
10952
10953         case SHT_MIPS_GPTAB:
10954           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10955           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10956           BFD_ASSERT (name != NULL
10957                       && CONST_STRNEQ (name, ".gptab."));
10958           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
10959           BFD_ASSERT (sec != NULL);
10960           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
10961           break;
10962
10963         case SHT_MIPS_CONTENT:
10964           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10965           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10966           BFD_ASSERT (name != NULL
10967                       && CONST_STRNEQ (name, ".MIPS.content"));
10968           sec = bfd_get_section_by_name (abfd,
10969                                          name + sizeof ".MIPS.content" - 1);
10970           BFD_ASSERT (sec != NULL);
10971           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10972           break;
10973
10974         case SHT_MIPS_SYMBOL_LIB:
10975           sec = bfd_get_section_by_name (abfd, ".dynsym");
10976           if (sec != NULL)
10977             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10978           sec = bfd_get_section_by_name (abfd, ".liblist");
10979           if (sec != NULL)
10980             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
10981           break;
10982
10983         case SHT_MIPS_EVENTS:
10984           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10985           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10986           BFD_ASSERT (name != NULL);
10987           if (CONST_STRNEQ (name, ".MIPS.events"))
10988             sec = bfd_get_section_by_name (abfd,
10989                                            name + sizeof ".MIPS.events" - 1);
10990           else
10991             {
10992               BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
10993               sec = bfd_get_section_by_name (abfd,
10994                                              (name
10995                                               + sizeof ".MIPS.post_rel" - 1));
10996             }
10997           BFD_ASSERT (sec != NULL);
10998           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10999           break;
11000
11001         }
11002     }
11003 }
11004 \f
11005 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
11006    segments.  */
11007
11008 int
11009 _bfd_mips_elf_additional_program_headers (bfd *abfd,
11010                                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
11011 {
11012   asection *s;
11013   int ret = 0;
11014
11015   /* See if we need a PT_MIPS_REGINFO segment.  */
11016   s = bfd_get_section_by_name (abfd, ".reginfo");
11017   if (s && (s->flags & SEC_LOAD))
11018     ++ret;
11019
11020   /* See if we need a PT_MIPS_OPTIONS segment.  */
11021   if (IRIX_COMPAT (abfd) == ict_irix6
11022       && bfd_get_section_by_name (abfd,
11023                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
11024     ++ret;
11025
11026   /* See if we need a PT_MIPS_RTPROC segment.  */
11027   if (IRIX_COMPAT (abfd) == ict_irix5
11028       && bfd_get_section_by_name (abfd, ".dynamic")
11029       && bfd_get_section_by_name (abfd, ".mdebug"))
11030     ++ret;
11031
11032   /* Allocate a PT_NULL header in dynamic objects.  See
11033      _bfd_mips_elf_modify_segment_map for details.  */
11034   if (!SGI_COMPAT (abfd)
11035       && bfd_get_section_by_name (abfd, ".dynamic"))
11036     ++ret;
11037
11038   return ret;
11039 }
11040
11041 /* Modify the segment map for an IRIX5 executable.  */
11042
11043 bfd_boolean
11044 _bfd_mips_elf_modify_segment_map (bfd *abfd,
11045                                   struct bfd_link_info *info)
11046 {
11047   asection *s;
11048   struct elf_segment_map *m, **pm;
11049   bfd_size_type amt;
11050
11051   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
11052      segment.  */
11053   s = bfd_get_section_by_name (abfd, ".reginfo");
11054   if (s != NULL && (s->flags & SEC_LOAD) != 0)
11055     {
11056       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11057         if (m->p_type == PT_MIPS_REGINFO)
11058           break;
11059       if (m == NULL)
11060         {
11061           amt = sizeof *m;
11062           m = bfd_zalloc (abfd, amt);
11063           if (m == NULL)
11064             return FALSE;
11065
11066           m->p_type = PT_MIPS_REGINFO;
11067           m->count = 1;
11068           m->sections[0] = s;
11069
11070           /* We want to put it after the PHDR and INTERP segments.  */
11071           pm = &elf_tdata (abfd)->segment_map;
11072           while (*pm != NULL
11073                  && ((*pm)->p_type == PT_PHDR
11074                      || (*pm)->p_type == PT_INTERP))
11075             pm = &(*pm)->next;
11076
11077           m->next = *pm;
11078           *pm = m;
11079         }
11080     }
11081
11082   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
11083      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
11084      PT_MIPS_OPTIONS segment immediately following the program header
11085      table.  */
11086   if (NEWABI_P (abfd)
11087       /* On non-IRIX6 new abi, we'll have already created a segment
11088          for this section, so don't create another.  I'm not sure this
11089          is not also the case for IRIX 6, but I can't test it right
11090          now.  */
11091       && IRIX_COMPAT (abfd) == ict_irix6)
11092     {
11093       for (s = abfd->sections; s; s = s->next)
11094         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
11095           break;
11096
11097       if (s)
11098         {
11099           struct elf_segment_map *options_segment;
11100
11101           pm = &elf_tdata (abfd)->segment_map;
11102           while (*pm != NULL
11103                  && ((*pm)->p_type == PT_PHDR
11104                      || (*pm)->p_type == PT_INTERP))
11105             pm = &(*pm)->next;
11106
11107           if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
11108             {
11109               amt = sizeof (struct elf_segment_map);
11110               options_segment = bfd_zalloc (abfd, amt);
11111               options_segment->next = *pm;
11112               options_segment->p_type = PT_MIPS_OPTIONS;
11113               options_segment->p_flags = PF_R;
11114               options_segment->p_flags_valid = TRUE;
11115               options_segment->count = 1;
11116               options_segment->sections[0] = s;
11117               *pm = options_segment;
11118             }
11119         }
11120     }
11121   else
11122     {
11123       if (IRIX_COMPAT (abfd) == ict_irix5)
11124         {
11125           /* If there are .dynamic and .mdebug sections, we make a room
11126              for the RTPROC header.  FIXME: Rewrite without section names.  */
11127           if (bfd_get_section_by_name (abfd, ".interp") == NULL
11128               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
11129               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
11130             {
11131               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11132                 if (m->p_type == PT_MIPS_RTPROC)
11133                   break;
11134               if (m == NULL)
11135                 {
11136                   amt = sizeof *m;
11137                   m = bfd_zalloc (abfd, amt);
11138                   if (m == NULL)
11139                     return FALSE;
11140
11141                   m->p_type = PT_MIPS_RTPROC;
11142
11143                   s = bfd_get_section_by_name (abfd, ".rtproc");
11144                   if (s == NULL)
11145                     {
11146                       m->count = 0;
11147                       m->p_flags = 0;
11148                       m->p_flags_valid = 1;
11149                     }
11150                   else
11151                     {
11152                       m->count = 1;
11153                       m->sections[0] = s;
11154                     }
11155
11156                   /* We want to put it after the DYNAMIC segment.  */
11157                   pm = &elf_tdata (abfd)->segment_map;
11158                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
11159                     pm = &(*pm)->next;
11160                   if (*pm != NULL)
11161                     pm = &(*pm)->next;
11162
11163                   m->next = *pm;
11164                   *pm = m;
11165                 }
11166             }
11167         }
11168       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
11169          .dynstr, .dynsym, and .hash sections, and everything in
11170          between.  */
11171       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
11172            pm = &(*pm)->next)
11173         if ((*pm)->p_type == PT_DYNAMIC)
11174           break;
11175       m = *pm;
11176       if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
11177         {
11178           /* For a normal mips executable the permissions for the PT_DYNAMIC
11179              segment are read, write and execute. We do that here since
11180              the code in elf.c sets only the read permission. This matters
11181              sometimes for the dynamic linker.  */
11182           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
11183             {
11184               m->p_flags = PF_R | PF_W | PF_X;
11185               m->p_flags_valid = 1;
11186             }
11187         }
11188       /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
11189          glibc's dynamic linker has traditionally derived the number of
11190          tags from the p_filesz field, and sometimes allocates stack
11191          arrays of that size.  An overly-big PT_DYNAMIC segment can
11192          be actively harmful in such cases.  Making PT_DYNAMIC contain
11193          other sections can also make life hard for the prelinker,
11194          which might move one of the other sections to a different
11195          PT_LOAD segment.  */
11196       if (SGI_COMPAT (abfd)
11197           && m != NULL
11198           && m->count == 1
11199           && strcmp (m->sections[0]->name, ".dynamic") == 0)
11200         {
11201           static const char *sec_names[] =
11202           {
11203             ".dynamic", ".dynstr", ".dynsym", ".hash"
11204           };
11205           bfd_vma low, high;
11206           unsigned int i, c;
11207           struct elf_segment_map *n;
11208
11209           low = ~(bfd_vma) 0;
11210           high = 0;
11211           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
11212             {
11213               s = bfd_get_section_by_name (abfd, sec_names[i]);
11214               if (s != NULL && (s->flags & SEC_LOAD) != 0)
11215                 {
11216                   bfd_size_type sz;
11217
11218                   if (low > s->vma)
11219                     low = s->vma;
11220                   sz = s->size;
11221                   if (high < s->vma + sz)
11222                     high = s->vma + sz;
11223                 }
11224             }
11225
11226           c = 0;
11227           for (s = abfd->sections; s != NULL; s = s->next)
11228             if ((s->flags & SEC_LOAD) != 0
11229                 && s->vma >= low
11230                 && s->vma + s->size <= high)
11231               ++c;
11232
11233           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
11234           n = bfd_zalloc (abfd, amt);
11235           if (n == NULL)
11236             return FALSE;
11237           *n = *m;
11238           n->count = c;
11239
11240           i = 0;
11241           for (s = abfd->sections; s != NULL; s = s->next)
11242             {
11243               if ((s->flags & SEC_LOAD) != 0
11244                   && s->vma >= low
11245                   && s->vma + s->size <= high)
11246                 {
11247                   n->sections[i] = s;
11248                   ++i;
11249                 }
11250             }
11251
11252           *pm = n;
11253         }
11254     }
11255
11256   /* Allocate a spare program header in dynamic objects so that tools
11257      like the prelinker can add an extra PT_LOAD entry.
11258
11259      If the prelinker needs to make room for a new PT_LOAD entry, its
11260      standard procedure is to move the first (read-only) sections into
11261      the new (writable) segment.  However, the MIPS ABI requires
11262      .dynamic to be in a read-only segment, and the section will often
11263      start within sizeof (ElfNN_Phdr) bytes of the last program header.
11264
11265      Although the prelinker could in principle move .dynamic to a
11266      writable segment, it seems better to allocate a spare program
11267      header instead, and avoid the need to move any sections.
11268      There is a long tradition of allocating spare dynamic tags,
11269      so allocating a spare program header seems like a natural
11270      extension.
11271
11272      If INFO is NULL, we may be copying an already prelinked binary
11273      with objcopy or strip, so do not add this header.  */
11274   if (info != NULL
11275       && !SGI_COMPAT (abfd)
11276       && bfd_get_section_by_name (abfd, ".dynamic"))
11277     {
11278       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
11279         if ((*pm)->p_type == PT_NULL)
11280           break;
11281       if (*pm == NULL)
11282         {
11283           m = bfd_zalloc (abfd, sizeof (*m));
11284           if (m == NULL)
11285             return FALSE;
11286
11287           m->p_type = PT_NULL;
11288           *pm = m;
11289         }
11290     }
11291
11292   return TRUE;
11293 }
11294 \f
11295 /* Return the section that should be marked against GC for a given
11296    relocation.  */
11297
11298 asection *
11299 _bfd_mips_elf_gc_mark_hook (asection *sec,
11300                             struct bfd_link_info *info,
11301                             Elf_Internal_Rela *rel,
11302                             struct elf_link_hash_entry *h,
11303                             Elf_Internal_Sym *sym)
11304 {
11305   /* ??? Do mips16 stub sections need to be handled special?  */
11306
11307   if (h != NULL)
11308     switch (ELF_R_TYPE (sec->owner, rel->r_info))
11309       {
11310       case R_MIPS_GNU_VTINHERIT:
11311       case R_MIPS_GNU_VTENTRY:
11312         return NULL;
11313       }
11314
11315   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11316 }
11317
11318 /* Update the got entry reference counts for the section being removed.  */
11319
11320 bfd_boolean
11321 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
11322                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
11323                              asection *sec ATTRIBUTE_UNUSED,
11324                              const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
11325 {
11326 #if 0
11327   Elf_Internal_Shdr *symtab_hdr;
11328   struct elf_link_hash_entry **sym_hashes;
11329   bfd_signed_vma *local_got_refcounts;
11330   const Elf_Internal_Rela *rel, *relend;
11331   unsigned long r_symndx;
11332   struct elf_link_hash_entry *h;
11333
11334   if (info->relocatable)
11335     return TRUE;
11336
11337   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11338   sym_hashes = elf_sym_hashes (abfd);
11339   local_got_refcounts = elf_local_got_refcounts (abfd);
11340
11341   relend = relocs + sec->reloc_count;
11342   for (rel = relocs; rel < relend; rel++)
11343     switch (ELF_R_TYPE (abfd, rel->r_info))
11344       {
11345       case R_MIPS16_GOT16:
11346       case R_MIPS16_CALL16:
11347       case R_MIPS_GOT16:
11348       case R_MIPS_CALL16:
11349       case R_MIPS_CALL_HI16:
11350       case R_MIPS_CALL_LO16:
11351       case R_MIPS_GOT_HI16:
11352       case R_MIPS_GOT_LO16:
11353       case R_MIPS_GOT_DISP:
11354       case R_MIPS_GOT_PAGE:
11355       case R_MIPS_GOT_OFST:
11356       case R_MICROMIPS_GOT16:
11357       case R_MICROMIPS_CALL16:
11358       case R_MICROMIPS_CALL_HI16:
11359       case R_MICROMIPS_CALL_LO16:
11360       case R_MICROMIPS_GOT_HI16:
11361       case R_MICROMIPS_GOT_LO16:
11362       case R_MICROMIPS_GOT_DISP:
11363       case R_MICROMIPS_GOT_PAGE:
11364       case R_MICROMIPS_GOT_OFST:
11365         /* ??? It would seem that the existing MIPS code does no sort
11366            of reference counting or whatnot on its GOT and PLT entries,
11367            so it is not possible to garbage collect them at this time.  */
11368         break;
11369
11370       default:
11371         break;
11372       }
11373 #endif
11374
11375   return TRUE;
11376 }
11377 \f
11378 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11379    hiding the old indirect symbol.  Process additional relocation
11380    information.  Also called for weakdefs, in which case we just let
11381    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
11382
11383 void
11384 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
11385                                     struct elf_link_hash_entry *dir,
11386                                     struct elf_link_hash_entry *ind)
11387 {
11388   struct mips_elf_link_hash_entry *dirmips, *indmips;
11389
11390   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
11391
11392   dirmips = (struct mips_elf_link_hash_entry *) dir;
11393   indmips = (struct mips_elf_link_hash_entry *) ind;
11394   /* Any absolute non-dynamic relocations against an indirect or weak
11395      definition will be against the target symbol.  */
11396   if (indmips->has_static_relocs)
11397     dirmips->has_static_relocs = TRUE;
11398
11399   if (ind->root.type != bfd_link_hash_indirect)
11400     return;
11401
11402   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
11403   if (indmips->readonly_reloc)
11404     dirmips->readonly_reloc = TRUE;
11405   if (indmips->no_fn_stub)
11406     dirmips->no_fn_stub = TRUE;
11407   if (indmips->fn_stub)
11408     {
11409       dirmips->fn_stub = indmips->fn_stub;
11410       indmips->fn_stub = NULL;
11411     }
11412   if (indmips->need_fn_stub)
11413     {
11414       dirmips->need_fn_stub = TRUE;
11415       indmips->need_fn_stub = FALSE;
11416     }
11417   if (indmips->call_stub)
11418     {
11419       dirmips->call_stub = indmips->call_stub;
11420       indmips->call_stub = NULL;
11421     }
11422   if (indmips->call_fp_stub)
11423     {
11424       dirmips->call_fp_stub = indmips->call_fp_stub;
11425       indmips->call_fp_stub = NULL;
11426     }
11427   if (indmips->global_got_area < dirmips->global_got_area)
11428     dirmips->global_got_area = indmips->global_got_area;
11429   if (indmips->global_got_area < GGA_NONE)
11430     indmips->global_got_area = GGA_NONE;
11431   if (indmips->has_nonpic_branches)
11432     dirmips->has_nonpic_branches = TRUE;
11433
11434   if (dirmips->tls_type == 0)
11435     dirmips->tls_type = indmips->tls_type;
11436 }
11437 \f
11438 #define PDR_SIZE 32
11439
11440 bfd_boolean
11441 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
11442                             struct bfd_link_info *info)
11443 {
11444   asection *o;
11445   bfd_boolean ret = FALSE;
11446   unsigned char *tdata;
11447   size_t i, skip;
11448
11449   o = bfd_get_section_by_name (abfd, ".pdr");
11450   if (! o)
11451     return FALSE;
11452   if (o->size == 0)
11453     return FALSE;
11454   if (o->size % PDR_SIZE != 0)
11455     return FALSE;
11456   if (o->output_section != NULL
11457       && bfd_is_abs_section (o->output_section))
11458     return FALSE;
11459
11460   tdata = bfd_zmalloc (o->size / PDR_SIZE);
11461   if (! tdata)
11462     return FALSE;
11463
11464   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
11465                                             info->keep_memory);
11466   if (!cookie->rels)
11467     {
11468       free (tdata);
11469       return FALSE;
11470     }
11471
11472   cookie->rel = cookie->rels;
11473   cookie->relend = cookie->rels + o->reloc_count;
11474
11475   for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
11476     {
11477       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
11478         {
11479           tdata[i] = 1;
11480           skip ++;
11481         }
11482     }
11483
11484   if (skip != 0)
11485     {
11486       mips_elf_section_data (o)->u.tdata = tdata;
11487       o->size -= skip * PDR_SIZE;
11488       ret = TRUE;
11489     }
11490   else
11491     free (tdata);
11492
11493   if (! info->keep_memory)
11494     free (cookie->rels);
11495
11496   return ret;
11497 }
11498
11499 bfd_boolean
11500 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
11501 {
11502   if (strcmp (sec->name, ".pdr") == 0)
11503     return TRUE;
11504   return FALSE;
11505 }
11506
11507 bfd_boolean
11508 _bfd_mips_elf_write_section (bfd *output_bfd,
11509                              struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
11510                              asection *sec, bfd_byte *contents)
11511 {
11512   bfd_byte *to, *from, *end;
11513   int i;
11514
11515   if (strcmp (sec->name, ".pdr") != 0)
11516     return FALSE;
11517
11518   if (mips_elf_section_data (sec)->u.tdata == NULL)
11519     return FALSE;
11520
11521   to = contents;
11522   end = contents + sec->size;
11523   for (from = contents, i = 0;
11524        from < end;
11525        from += PDR_SIZE, i++)
11526     {
11527       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
11528         continue;
11529       if (to != from)
11530         memcpy (to, from, PDR_SIZE);
11531       to += PDR_SIZE;
11532     }
11533   bfd_set_section_contents (output_bfd, sec->output_section, contents,
11534                             sec->output_offset, sec->size);
11535   return TRUE;
11536 }
11537 \f
11538 /* microMIPS code retains local labels for linker relaxation.  Omit them
11539    from output by default for clarity.  */
11540
11541 bfd_boolean
11542 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
11543 {
11544   return _bfd_elf_is_local_label_name (abfd, sym->name);
11545 }
11546
11547 /* MIPS ELF uses a special find_nearest_line routine in order the
11548    handle the ECOFF debugging information.  */
11549
11550 struct mips_elf_find_line
11551 {
11552   struct ecoff_debug_info d;
11553   struct ecoff_find_line i;
11554 };
11555
11556 bfd_boolean
11557 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
11558                                  asymbol **symbols, bfd_vma offset,
11559                                  const char **filename_ptr,
11560                                  const char **functionname_ptr,
11561                                  unsigned int *line_ptr)
11562 {
11563   asection *msec;
11564
11565   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
11566                                      filename_ptr, functionname_ptr,
11567                                      line_ptr))
11568     return TRUE;
11569
11570   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11571                                      filename_ptr, functionname_ptr,
11572                                      line_ptr, ABI_64_P (abfd) ? 8 : 0,
11573                                      &elf_tdata (abfd)->dwarf2_find_line_info))
11574     return TRUE;
11575
11576   msec = bfd_get_section_by_name (abfd, ".mdebug");
11577   if (msec != NULL)
11578     {
11579       flagword origflags;
11580       struct mips_elf_find_line *fi;
11581       const struct ecoff_debug_swap * const swap =
11582         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
11583
11584       /* If we are called during a link, mips_elf_final_link may have
11585          cleared the SEC_HAS_CONTENTS field.  We force it back on here
11586          if appropriate (which it normally will be).  */
11587       origflags = msec->flags;
11588       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
11589         msec->flags |= SEC_HAS_CONTENTS;
11590
11591       fi = elf_tdata (abfd)->find_line_info;
11592       if (fi == NULL)
11593         {
11594           bfd_size_type external_fdr_size;
11595           char *fraw_src;
11596           char *fraw_end;
11597           struct fdr *fdr_ptr;
11598           bfd_size_type amt = sizeof (struct mips_elf_find_line);
11599
11600           fi = bfd_zalloc (abfd, amt);
11601           if (fi == NULL)
11602             {
11603               msec->flags = origflags;
11604               return FALSE;
11605             }
11606
11607           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
11608             {
11609               msec->flags = origflags;
11610               return FALSE;
11611             }
11612
11613           /* Swap in the FDR information.  */
11614           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
11615           fi->d.fdr = bfd_alloc (abfd, amt);
11616           if (fi->d.fdr == NULL)
11617             {
11618               msec->flags = origflags;
11619               return FALSE;
11620             }
11621           external_fdr_size = swap->external_fdr_size;
11622           fdr_ptr = fi->d.fdr;
11623           fraw_src = (char *) fi->d.external_fdr;
11624           fraw_end = (fraw_src
11625                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
11626           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
11627             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
11628
11629           elf_tdata (abfd)->find_line_info = fi;
11630
11631           /* Note that we don't bother to ever free this information.
11632              find_nearest_line is either called all the time, as in
11633              objdump -l, so the information should be saved, or it is
11634              rarely called, as in ld error messages, so the memory
11635              wasted is unimportant.  Still, it would probably be a
11636              good idea for free_cached_info to throw it away.  */
11637         }
11638
11639       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
11640                                   &fi->i, filename_ptr, functionname_ptr,
11641                                   line_ptr))
11642         {
11643           msec->flags = origflags;
11644           return TRUE;
11645         }
11646
11647       msec->flags = origflags;
11648     }
11649
11650   /* Fall back on the generic ELF find_nearest_line routine.  */
11651
11652   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
11653                                      filename_ptr, functionname_ptr,
11654                                      line_ptr);
11655 }
11656
11657 bfd_boolean
11658 _bfd_mips_elf_find_inliner_info (bfd *abfd,
11659                                  const char **filename_ptr,
11660                                  const char **functionname_ptr,
11661                                  unsigned int *line_ptr)
11662 {
11663   bfd_boolean found;
11664   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11665                                          functionname_ptr, line_ptr,
11666                                          & elf_tdata (abfd)->dwarf2_find_line_info);
11667   return found;
11668 }
11669
11670 \f
11671 /* When are writing out the .options or .MIPS.options section,
11672    remember the bytes we are writing out, so that we can install the
11673    GP value in the section_processing routine.  */
11674
11675 bfd_boolean
11676 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
11677                                     const void *location,
11678                                     file_ptr offset, bfd_size_type count)
11679 {
11680   if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
11681     {
11682       bfd_byte *c;
11683
11684       if (elf_section_data (section) == NULL)
11685         {
11686           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
11687           section->used_by_bfd = bfd_zalloc (abfd, amt);
11688           if (elf_section_data (section) == NULL)
11689             return FALSE;
11690         }
11691       c = mips_elf_section_data (section)->u.tdata;
11692       if (c == NULL)
11693         {
11694           c = bfd_zalloc (abfd, section->size);
11695           if (c == NULL)
11696             return FALSE;
11697           mips_elf_section_data (section)->u.tdata = c;
11698         }
11699
11700       memcpy (c + offset, location, count);
11701     }
11702
11703   return _bfd_elf_set_section_contents (abfd, section, location, offset,
11704                                         count);
11705 }
11706
11707 /* This is almost identical to bfd_generic_get_... except that some
11708    MIPS relocations need to be handled specially.  Sigh.  */
11709
11710 bfd_byte *
11711 _bfd_elf_mips_get_relocated_section_contents
11712   (bfd *abfd,
11713    struct bfd_link_info *link_info,
11714    struct bfd_link_order *link_order,
11715    bfd_byte *data,
11716    bfd_boolean relocatable,
11717    asymbol **symbols)
11718 {
11719   /* Get enough memory to hold the stuff */
11720   bfd *input_bfd = link_order->u.indirect.section->owner;
11721   asection *input_section = link_order->u.indirect.section;
11722   bfd_size_type sz;
11723
11724   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
11725   arelent **reloc_vector = NULL;
11726   long reloc_count;
11727
11728   if (reloc_size < 0)
11729     goto error_return;
11730
11731   reloc_vector = bfd_malloc (reloc_size);
11732   if (reloc_vector == NULL && reloc_size != 0)
11733     goto error_return;
11734
11735   /* read in the section */
11736   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
11737   if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
11738     goto error_return;
11739
11740   reloc_count = bfd_canonicalize_reloc (input_bfd,
11741                                         input_section,
11742                                         reloc_vector,
11743                                         symbols);
11744   if (reloc_count < 0)
11745     goto error_return;
11746
11747   if (reloc_count > 0)
11748     {
11749       arelent **parent;
11750       /* for mips */
11751       int gp_found;
11752       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
11753
11754       {
11755         struct bfd_hash_entry *h;
11756         struct bfd_link_hash_entry *lh;
11757         /* Skip all this stuff if we aren't mixing formats.  */
11758         if (abfd && input_bfd
11759             && abfd->xvec == input_bfd->xvec)
11760           lh = 0;
11761         else
11762           {
11763             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
11764             lh = (struct bfd_link_hash_entry *) h;
11765           }
11766       lookup:
11767         if (lh)
11768           {
11769             switch (lh->type)
11770               {
11771               case bfd_link_hash_undefined:
11772               case bfd_link_hash_undefweak:
11773               case bfd_link_hash_common:
11774                 gp_found = 0;
11775                 break;
11776               case bfd_link_hash_defined:
11777               case bfd_link_hash_defweak:
11778                 gp_found = 1;
11779                 gp = lh->u.def.value;
11780                 break;
11781               case bfd_link_hash_indirect:
11782               case bfd_link_hash_warning:
11783                 lh = lh->u.i.link;
11784                 /* @@FIXME  ignoring warning for now */
11785                 goto lookup;
11786               case bfd_link_hash_new:
11787               default:
11788                 abort ();
11789               }
11790           }
11791         else
11792           gp_found = 0;
11793       }
11794       /* end mips */
11795       for (parent = reloc_vector; *parent != NULL; parent++)
11796         {
11797           char *error_message = NULL;
11798           bfd_reloc_status_type r;
11799
11800           /* Specific to MIPS: Deal with relocation types that require
11801              knowing the gp of the output bfd.  */
11802           asymbol *sym = *(*parent)->sym_ptr_ptr;
11803
11804           /* If we've managed to find the gp and have a special
11805              function for the relocation then go ahead, else default
11806              to the generic handling.  */
11807           if (gp_found
11808               && (*parent)->howto->special_function
11809               == _bfd_mips_elf32_gprel16_reloc)
11810             r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
11811                                                input_section, relocatable,
11812                                                data, gp);
11813           else
11814             r = bfd_perform_relocation (input_bfd, *parent, data,
11815                                         input_section,
11816                                         relocatable ? abfd : NULL,
11817                                         &error_message);
11818
11819           if (relocatable)
11820             {
11821               asection *os = input_section->output_section;
11822
11823               /* A partial link, so keep the relocs */
11824               os->orelocation[os->reloc_count] = *parent;
11825               os->reloc_count++;
11826             }
11827
11828           if (r != bfd_reloc_ok)
11829             {
11830               switch (r)
11831                 {
11832                 case bfd_reloc_undefined:
11833                   if (!((*link_info->callbacks->undefined_symbol)
11834                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11835                          input_bfd, input_section, (*parent)->address, TRUE)))
11836                     goto error_return;
11837                   break;
11838                 case bfd_reloc_dangerous:
11839                   BFD_ASSERT (error_message != NULL);
11840                   if (!((*link_info->callbacks->reloc_dangerous)
11841                         (link_info, error_message, input_bfd, input_section,
11842                          (*parent)->address)))
11843                     goto error_return;
11844                   break;
11845                 case bfd_reloc_overflow:
11846                   if (!((*link_info->callbacks->reloc_overflow)
11847                         (link_info, NULL,
11848                          bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11849                          (*parent)->howto->name, (*parent)->addend,
11850                          input_bfd, input_section, (*parent)->address)))
11851                     goto error_return;
11852                   break;
11853                 case bfd_reloc_outofrange:
11854                 default:
11855                   abort ();
11856                   break;
11857                 }
11858
11859             }
11860         }
11861     }
11862   if (reloc_vector != NULL)
11863     free (reloc_vector);
11864   return data;
11865
11866 error_return:
11867   if (reloc_vector != NULL)
11868     free (reloc_vector);
11869   return NULL;
11870 }
11871 \f
11872 static bfd_boolean
11873 mips_elf_relax_delete_bytes (bfd *abfd,
11874                              asection *sec, bfd_vma addr, int count)
11875 {
11876   Elf_Internal_Shdr *symtab_hdr;
11877   unsigned int sec_shndx;
11878   bfd_byte *contents;
11879   Elf_Internal_Rela *irel, *irelend;
11880   Elf_Internal_Sym *isym;
11881   Elf_Internal_Sym *isymend;
11882   struct elf_link_hash_entry **sym_hashes;
11883   struct elf_link_hash_entry **end_hashes;
11884   struct elf_link_hash_entry **start_hashes;
11885   unsigned int symcount;
11886
11887   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
11888   contents = elf_section_data (sec)->this_hdr.contents;
11889
11890   irel = elf_section_data (sec)->relocs;
11891   irelend = irel + sec->reloc_count;
11892
11893   /* Actually delete the bytes.  */
11894   memmove (contents + addr, contents + addr + count,
11895            (size_t) (sec->size - addr - count));
11896   sec->size -= count;
11897
11898   /* Adjust all the relocs.  */
11899   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
11900     {
11901       /* Get the new reloc address.  */
11902       if (irel->r_offset > addr)
11903         irel->r_offset -= count;
11904     }
11905
11906   BFD_ASSERT (addr % 2 == 0);
11907   BFD_ASSERT (count % 2 == 0);
11908
11909   /* Adjust the local symbols defined in this section.  */
11910   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11911   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
11912   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
11913     if (isym->st_shndx == sec_shndx && isym->st_value > addr)
11914       isym->st_value -= count;
11915
11916   /* Now adjust the global symbols defined in this section.  */
11917   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
11918               - symtab_hdr->sh_info);
11919   sym_hashes = start_hashes = elf_sym_hashes (abfd);
11920   end_hashes = sym_hashes + symcount;
11921
11922   for (; sym_hashes < end_hashes; sym_hashes++)
11923     {
11924       struct elf_link_hash_entry *sym_hash = *sym_hashes;
11925
11926       if ((sym_hash->root.type == bfd_link_hash_defined
11927            || sym_hash->root.type == bfd_link_hash_defweak)
11928           && sym_hash->root.u.def.section == sec)
11929         {
11930           bfd_vma value = sym_hash->root.u.def.value;
11931
11932           if (ELF_ST_IS_MICROMIPS (sym_hash->other))
11933             value &= MINUS_TWO;
11934           if (value > addr)
11935             sym_hash->root.u.def.value -= count;
11936         }
11937     }
11938
11939   return TRUE;
11940 }
11941
11942
11943 /* Opcodes needed for microMIPS relaxation as found in
11944    opcodes/micromips-opc.c.  */
11945
11946 struct opcode_descriptor {
11947   unsigned long match;
11948   unsigned long mask;
11949 };
11950
11951 /* The $ra register aka $31.  */
11952
11953 #define RA 31
11954
11955 /* 32-bit instruction format register fields.  */
11956
11957 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
11958 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
11959
11960 /* Check if a 5-bit register index can be abbreviated to 3 bits.  */
11961
11962 #define OP16_VALID_REG(r) \
11963   ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
11964
11965
11966 /* 32-bit and 16-bit branches.  */
11967
11968 static const struct opcode_descriptor b_insns_32[] = {
11969   { /* "b",     "p",            */ 0x40400000, 0xffff0000 }, /* bgez 0 */
11970   { /* "b",     "p",            */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
11971   { 0, 0 }  /* End marker for find_match().  */
11972 };
11973
11974 static const struct opcode_descriptor bc_insn_32 =
11975   { /* "bc(1|2)(ft)", "N,p",    */ 0x42800000, 0xfec30000 };
11976
11977 static const struct opcode_descriptor bz_insn_32 =
11978   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 };
11979
11980 static const struct opcode_descriptor bzal_insn_32 =
11981   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 };
11982
11983 static const struct opcode_descriptor beq_insn_32 =
11984   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 };
11985
11986 static const struct opcode_descriptor b_insn_16 =
11987   { /* "b",     "mD",           */ 0xcc00,     0xfc00 };
11988
11989 static const struct opcode_descriptor bz_insn_16 =
11990   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 };
11991
11992
11993 /* 32-bit and 16-bit branch EQ and NE zero.  */
11994
11995 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
11996    eq and second the ne.  This convention is used when replacing a
11997    32-bit BEQ/BNE with the 16-bit version.  */
11998
11999 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
12000
12001 static const struct opcode_descriptor bz_rs_insns_32[] = {
12002   { /* "beqz",  "s,p",          */ 0x94000000, 0xffe00000 },
12003   { /* "bnez",  "s,p",          */ 0xb4000000, 0xffe00000 },
12004   { 0, 0 }  /* End marker for find_match().  */
12005 };
12006
12007 static const struct opcode_descriptor bz_rt_insns_32[] = {
12008   { /* "beqz",  "t,p",          */ 0x94000000, 0xfc01f000 },
12009   { /* "bnez",  "t,p",          */ 0xb4000000, 0xfc01f000 },
12010   { 0, 0 }  /* End marker for find_match().  */
12011 };
12012
12013 static const struct opcode_descriptor bzc_insns_32[] = {
12014   { /* "beqzc", "s,p",          */ 0x40e00000, 0xffe00000 },
12015   { /* "bnezc", "s,p",          */ 0x40a00000, 0xffe00000 },
12016   { 0, 0 }  /* End marker for find_match().  */
12017 };
12018
12019 static const struct opcode_descriptor bz_insns_16[] = {
12020   { /* "beqz",  "md,mE",        */ 0x8c00,     0xfc00 },
12021   { /* "bnez",  "md,mE",        */ 0xac00,     0xfc00 },
12022   { 0, 0 }  /* End marker for find_match().  */
12023 };
12024
12025 /* Switch between a 5-bit register index and its 3-bit shorthand.  */
12026
12027 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
12028 #define BZ16_REG_FIELD(r) \
12029   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
12030
12031
12032 /* 32-bit instructions with a delay slot.  */
12033
12034 static const struct opcode_descriptor jal_insn_32_bd16 =
12035   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 };
12036
12037 static const struct opcode_descriptor jal_insn_32_bd32 =
12038   { /* "jal",   "a",            */ 0xf4000000, 0xfc000000 };
12039
12040 static const struct opcode_descriptor jal_x_insn_32_bd32 =
12041   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 };
12042
12043 static const struct opcode_descriptor j_insn_32 =
12044   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 };
12045
12046 static const struct opcode_descriptor jalr_insn_32 =
12047   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff };
12048
12049 /* This table can be compacted, because no opcode replacement is made.  */
12050
12051 static const struct opcode_descriptor ds_insns_32_bd16[] = {
12052   { /* "jals",  "a",            */ 0x74000000, 0xfc000000 },
12053
12054   { /* "jalrs[.hb]", "t,s",     */ 0x00004f3c, 0xfc00efff },
12055   { /* "b(ge|lt)zals", "s,p",   */ 0x42200000, 0xffa00000 },
12056
12057   { /* "b(g|l)(e|t)z", "s,p",   */ 0x40000000, 0xff200000 },
12058   { /* "b(eq|ne)", "s,t,p",     */ 0x94000000, 0xdc000000 },
12059   { /* "j",     "a",            */ 0xd4000000, 0xfc000000 },
12060   { 0, 0 }  /* End marker for find_match().  */
12061 };
12062
12063 /* This table can be compacted, because no opcode replacement is made.  */
12064
12065 static const struct opcode_descriptor ds_insns_32_bd32[] = {
12066   { /* "jal[x]", "a",           */ 0xf0000000, 0xf8000000 },
12067
12068   { /* "jalr[.hb]", "t,s",      */ 0x00000f3c, 0xfc00efff },
12069   { /* "b(ge|lt)zal", "s,p",    */ 0x40200000, 0xffa00000 },
12070   { 0, 0 }  /* End marker for find_match().  */
12071 };
12072
12073
12074 /* 16-bit instructions with a delay slot.  */
12075
12076 static const struct opcode_descriptor jalr_insn_16_bd16 =
12077   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 };
12078
12079 static const struct opcode_descriptor jalr_insn_16_bd32 =
12080   { /* "jalr",  "my,mj",        */ 0x45c0,     0xffe0 };
12081
12082 static const struct opcode_descriptor jr_insn_16 =
12083   { /* "jr",    "mj",           */ 0x4580,     0xffe0 };
12084
12085 #define JR16_REG(opcode) ((opcode) & 0x1f)
12086
12087 /* This table can be compacted, because no opcode replacement is made.  */
12088
12089 static const struct opcode_descriptor ds_insns_16_bd16[] = {
12090   { /* "jalrs", "my,mj",        */ 0x45e0,     0xffe0 },
12091
12092   { /* "b",     "mD",           */ 0xcc00,     0xfc00 },
12093   { /* "b(eq|ne)z", "md,mE",    */ 0x8c00,     0xdc00 },
12094   { /* "jr",    "mj",           */ 0x4580,     0xffe0 },
12095   { 0, 0 }  /* End marker for find_match().  */
12096 };
12097
12098
12099 /* LUI instruction.  */
12100
12101 static const struct opcode_descriptor lui_insn =
12102  { /* "lui",    "s,u",          */ 0x41a00000, 0xffe00000 };
12103
12104
12105 /* ADDIU instruction.  */
12106
12107 static const struct opcode_descriptor addiu_insn =
12108   { /* "addiu", "t,r,j",        */ 0x30000000, 0xfc000000 };
12109
12110 static const struct opcode_descriptor addiupc_insn =
12111   { /* "addiu", "mb,$pc,mQ",    */ 0x78000000, 0xfc000000 };
12112
12113 #define ADDIUPC_REG_FIELD(r) \
12114   (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
12115
12116
12117 /* Relaxable instructions in a JAL delay slot: MOVE.  */
12118
12119 /* The 16-bit move has rd in 9:5 and rs in 4:0.  The 32-bit moves
12120    (ADDU, OR) have rd in 15:11 and rs in 10:16.  */
12121 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
12122 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
12123
12124 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
12125 #define MOVE16_RS_FIELD(r) (((r) & 0x1f)     )
12126
12127 static const struct opcode_descriptor move_insns_32[] = {
12128   { /* "move",  "d,s",          */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
12129   { /* "move",  "d,s",          */ 0x00000290, 0xffe007ff }, /* or   d,s,$0 */
12130   { 0, 0 }  /* End marker for find_match().  */
12131 };
12132
12133 static const struct opcode_descriptor move_insn_16 =
12134   { /* "move",  "mp,mj",        */ 0x0c00,     0xfc00 };
12135
12136
12137 /* NOP instructions.  */
12138
12139 static const struct opcode_descriptor nop_insn_32 =
12140   { /* "nop",   "",             */ 0x00000000, 0xffffffff };
12141
12142 static const struct opcode_descriptor nop_insn_16 =
12143   { /* "nop",   "",             */ 0x0c00,     0xffff };
12144
12145
12146 /* Instruction match support.  */
12147
12148 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
12149
12150 static int
12151 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
12152 {
12153   unsigned long indx;
12154
12155   for (indx = 0; insn[indx].mask != 0; indx++)
12156     if (MATCH (opcode, insn[indx]))
12157       return indx;
12158
12159   return -1;
12160 }
12161
12162
12163 /* Branch and delay slot decoding support.  */
12164
12165 /* If PTR points to what *might* be a 16-bit branch or jump, then
12166    return the minimum length of its delay slot, otherwise return 0.
12167    Non-zero results are not definitive as we might be checking against
12168    the second half of another instruction.  */
12169
12170 static int
12171 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
12172 {
12173   unsigned long opcode;
12174   int bdsize;
12175
12176   opcode = bfd_get_16 (abfd, ptr);
12177   if (MATCH (opcode, jalr_insn_16_bd32) != 0)
12178     /* 16-bit branch/jump with a 32-bit delay slot.  */
12179     bdsize = 4;
12180   else if (MATCH (opcode, jalr_insn_16_bd16) != 0
12181            || find_match (opcode, ds_insns_16_bd16) >= 0)
12182     /* 16-bit branch/jump with a 16-bit delay slot.  */
12183     bdsize = 2;
12184   else
12185     /* No delay slot.  */
12186     bdsize = 0;
12187
12188   return bdsize;
12189 }
12190
12191 /* If PTR points to what *might* be a 32-bit branch or jump, then
12192    return the minimum length of its delay slot, otherwise return 0.
12193    Non-zero results are not definitive as we might be checking against
12194    the second half of another instruction.  */
12195
12196 static int
12197 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
12198 {
12199   unsigned long opcode;
12200   int bdsize;
12201
12202   opcode = (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
12203   if (find_match (opcode, ds_insns_32_bd32) >= 0)
12204     /* 32-bit branch/jump with a 32-bit delay slot.  */
12205     bdsize = 4;
12206   else if (find_match (opcode, ds_insns_32_bd16) >= 0)
12207     /* 32-bit branch/jump with a 16-bit delay slot.  */
12208     bdsize = 2;
12209   else
12210     /* No delay slot.  */
12211     bdsize = 0;
12212
12213   return bdsize;
12214 }
12215
12216 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
12217    that doesn't fiddle with REG, then return TRUE, otherwise FALSE.  */
12218
12219 static bfd_boolean
12220 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12221 {
12222   unsigned long opcode;
12223
12224   opcode = bfd_get_16 (abfd, ptr);
12225   if (MATCH (opcode, b_insn_16)
12226                                                 /* B16  */
12227       || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
12228                                                 /* JR16  */
12229       || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
12230                                                 /* BEQZ16, BNEZ16  */
12231       || (MATCH (opcode, jalr_insn_16_bd32)
12232                                                 /* JALR16  */
12233           && reg != JR16_REG (opcode) && reg != RA))
12234     return TRUE;
12235
12236   return FALSE;
12237 }
12238
12239 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
12240    then return TRUE, otherwise FALSE.  */
12241
12242 static bfd_boolean
12243 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12244 {
12245   unsigned long opcode;
12246
12247   opcode = (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
12248   if (MATCH (opcode, j_insn_32)
12249                                                 /* J  */
12250       || MATCH (opcode, bc_insn_32)
12251                                                 /* BC1F, BC1T, BC2F, BC2T  */
12252       || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
12253                                                 /* JAL, JALX  */
12254       || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
12255                                                 /* BGEZ, BGTZ, BLEZ, BLTZ  */
12256       || (MATCH (opcode, bzal_insn_32)
12257                                                 /* BGEZAL, BLTZAL  */
12258           && reg != OP32_SREG (opcode) && reg != RA)
12259       || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
12260                                                 /* JALR, JALR.HB, BEQ, BNE  */
12261           && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
12262     return TRUE;
12263
12264   return FALSE;
12265 }
12266
12267 /* Bitsize checking.  */
12268 #define IS_BITSIZE(val, N)                                              \
12269   (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1)))               \
12270     - (1ULL << ((N) - 1))) == (val))
12271
12272 /* See if relocations [INTERNAL_RELOCS, IRELEND) confirm that there
12273    is a 4-byte branch at offset OFFSET.  */
12274
12275 static bfd_boolean
12276 check_4byte_branch (Elf_Internal_Rela *internal_relocs,
12277                     Elf_Internal_Rela *irelend, bfd_vma offset)
12278 {
12279   Elf_Internal_Rela *irel;
12280   unsigned long r_type;
12281
12282   for (irel = internal_relocs; irel < irelend; irel++)
12283     if (irel->r_offset == offset)
12284       {
12285         r_type = ELF32_R_TYPE (irel->r_info);
12286         if (r_type == R_MICROMIPS_26_S1
12287             || r_type == R_MICROMIPS_PC16_S1
12288             || r_type == R_MICROMIPS_JALR)
12289           return TRUE;
12290       }
12291   return FALSE;
12292 }
12293 \f
12294 bfd_boolean
12295 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
12296                              struct bfd_link_info *link_info,
12297                              bfd_boolean *again)
12298 {
12299   Elf_Internal_Shdr *symtab_hdr;
12300   Elf_Internal_Rela *internal_relocs;
12301   Elf_Internal_Rela *irel, *irelend;
12302   bfd_byte *contents = NULL;
12303   Elf_Internal_Sym *isymbuf = NULL;
12304
12305   /* Assume nothing changes.  */
12306   *again = FALSE;
12307
12308   /* We don't have to do anything for a relocatable link, if
12309      this section does not have relocs, or if this is not a
12310      code section.  */
12311
12312   if (link_info->relocatable
12313       || (sec->flags & SEC_RELOC) == 0
12314       || sec->reloc_count == 0
12315       || (sec->flags & SEC_CODE) == 0)
12316     return TRUE;
12317
12318   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12319
12320   /* Get a copy of the native relocations.  */
12321   internal_relocs = (_bfd_elf_link_read_relocs
12322                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
12323                       link_info->keep_memory));
12324   if (internal_relocs == NULL)
12325     goto error_return;
12326
12327   /* Walk through them looking for relaxing opportunities.  */
12328   irelend = internal_relocs + sec->reloc_count;
12329   for (irel = internal_relocs; irel < irelend; irel++)
12330     {
12331       unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
12332       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
12333       bfd_boolean target_is_micromips_code_p;
12334       unsigned long opcode;
12335       bfd_vma symval;
12336       bfd_vma pcrval;
12337       bfd_byte *ptr;
12338       int fndopc;
12339
12340       /* The number of bytes to delete for relaxation and from where
12341          to delete these bytes starting at irel->r_offset.  */
12342       int delcnt = 0;
12343       int deloff = 0;
12344
12345       /* If this isn't something that can be relaxed, then ignore
12346          this reloc.  */
12347       if (r_type != R_MICROMIPS_HI16
12348           && r_type != R_MICROMIPS_PC16_S1
12349           && r_type != R_MICROMIPS_26_S1)
12350         continue;
12351
12352       /* Get the section contents if we haven't done so already.  */
12353       if (contents == NULL)
12354         {
12355           /* Get cached copy if it exists.  */
12356           if (elf_section_data (sec)->this_hdr.contents != NULL)
12357             contents = elf_section_data (sec)->this_hdr.contents;
12358           /* Go get them off disk.  */
12359           else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
12360             goto error_return;
12361         }
12362       ptr = contents + irel->r_offset;
12363
12364       /* Read this BFD's local symbols if we haven't done so already.  */
12365       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
12366         {
12367           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
12368           if (isymbuf == NULL)
12369             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12370                                             symtab_hdr->sh_info, 0,
12371                                             NULL, NULL, NULL);
12372           if (isymbuf == NULL)
12373             goto error_return;
12374         }
12375
12376       /* Get the value of the symbol referred to by the reloc.  */
12377       if (r_symndx < symtab_hdr->sh_info)
12378         {
12379           /* A local symbol.  */
12380           Elf_Internal_Sym *isym;
12381           asection *sym_sec;
12382
12383           isym = isymbuf + r_symndx;
12384           if (isym->st_shndx == SHN_UNDEF)
12385             sym_sec = bfd_und_section_ptr;
12386           else if (isym->st_shndx == SHN_ABS)
12387             sym_sec = bfd_abs_section_ptr;
12388           else if (isym->st_shndx == SHN_COMMON)
12389             sym_sec = bfd_com_section_ptr;
12390           else
12391             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
12392           symval = (isym->st_value
12393                     + sym_sec->output_section->vma
12394                     + sym_sec->output_offset);
12395           target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
12396         }
12397       else
12398         {
12399           unsigned long indx;
12400           struct elf_link_hash_entry *h;
12401
12402           /* An external symbol.  */
12403           indx = r_symndx - symtab_hdr->sh_info;
12404           h = elf_sym_hashes (abfd)[indx];
12405           BFD_ASSERT (h != NULL);
12406
12407           if (h->root.type != bfd_link_hash_defined
12408               && h->root.type != bfd_link_hash_defweak)
12409             /* This appears to be a reference to an undefined
12410                symbol.  Just ignore it -- it will be caught by the
12411                regular reloc processing.  */
12412             continue;
12413
12414           symval = (h->root.u.def.value
12415                     + h->root.u.def.section->output_section->vma
12416                     + h->root.u.def.section->output_offset);
12417           target_is_micromips_code_p = (!h->needs_plt
12418                                         && ELF_ST_IS_MICROMIPS (h->other));
12419         }
12420
12421
12422       /* For simplicity of coding, we are going to modify the
12423          section contents, the section relocs, and the BFD symbol
12424          table.  We must tell the rest of the code not to free up this
12425          information.  It would be possible to instead create a table
12426          of changes which have to be made, as is done in coff-mips.c;
12427          that would be more work, but would require less memory when
12428          the linker is run.  */
12429
12430       /* Only 32-bit instructions relaxed.  */
12431       if (irel->r_offset + 4 > sec->size)
12432         continue;
12433
12434       opcode  = bfd_get_16 (abfd, ptr    ) << 16;
12435       opcode |= bfd_get_16 (abfd, ptr + 2);
12436
12437       /* This is the pc-relative distance from the instruction the
12438          relocation is applied to, to the symbol referred.  */
12439       pcrval = (symval
12440                 - (sec->output_section->vma + sec->output_offset)
12441                 - irel->r_offset);
12442
12443       /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
12444          of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
12445          R_MICROMIPS_PC23_S2.  The R_MICROMIPS_PC23_S2 condition is
12446
12447            (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
12448
12449          where pcrval has first to be adjusted to apply against the LO16
12450          location (we make the adjustment later on, when we have figured
12451          out the offset).  */
12452       if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
12453         {
12454           unsigned long nextopc;
12455           unsigned long reg;
12456           bfd_vma offset;
12457
12458           /* Give up if the previous reloc was a HI16 against this symbol
12459              too.  */
12460           if (irel > internal_relocs
12461               && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
12462               && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
12463             continue;
12464
12465           /* Or if the next reloc is not a LO16 against this symbol.  */
12466           if (irel + 1 >= irelend
12467               || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
12468               || ELF32_R_SYM (irel[1].r_info) != r_symndx)
12469             continue;
12470
12471           /* Or if the second next reloc is a LO16 against this symbol too.  */
12472           if (irel + 2 >= irelend
12473               && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
12474               && ELF32_R_SYM (irel[2].r_info) == r_symndx)
12475             continue;
12476
12477           /* See if the LUI instruction *might* be in a branch delay slot.  */
12478           if (irel->r_offset >= 2
12479               && check_br16_dslot (abfd, ptr - 2)
12480               && !(irel->r_offset >= 4
12481                    /* If the instruction is actually a 4-byte branch,
12482                       the value of check_br16_dslot doesn't matter.
12483                       We should use check_br32_dslot to check whether
12484                       the branch has a delay slot.  */
12485                    && check_4byte_branch (internal_relocs, irelend,
12486                                           irel->r_offset - 4)))
12487             continue;
12488           if (irel->r_offset >= 4
12489               && check_br32_dslot (abfd, ptr - 4))
12490             continue;
12491
12492           reg = OP32_SREG (opcode);
12493
12494           /* We only relax adjacent instructions or ones separated with
12495              a branch or jump that has a delay slot.  The branch or jump
12496              must not fiddle with the register used to hold the address.
12497              Subtract 4 for the LUI itself.  */
12498           offset = irel[1].r_offset - irel[0].r_offset;
12499           switch (offset - 4)
12500             {
12501             case 0:
12502               break;
12503             case 2:
12504               if (check_br16 (abfd, ptr + 4, reg))
12505                 break;
12506               continue;
12507             case 4:
12508               if (check_br32 (abfd, ptr + 4, reg))
12509                 break;
12510               continue;
12511             default:
12512               continue;
12513             }
12514
12515           nextopc  = bfd_get_16 (abfd, contents + irel[1].r_offset    ) << 16;
12516           nextopc |= bfd_get_16 (abfd, contents + irel[1].r_offset + 2);
12517
12518           /* Give up unless the same register is used with both
12519              relocations.  */
12520           if (OP32_SREG (nextopc) != reg)
12521             continue;
12522
12523           /* Now adjust pcrval, subtracting the offset to the LO16 reloc
12524              and rounding up to take masking of the two LSBs into account.  */
12525           pcrval = ((pcrval - offset + 3) | 3) ^ 3;
12526
12527           /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16.  */
12528           if (IS_BITSIZE (symval, 16))
12529             {
12530               /* Fix the relocation's type.  */
12531               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
12532
12533               /* Instructions using R_MICROMIPS_LO16 have the base or
12534                  source register in bits 20:16.  This register becomes $0
12535                  (zero) as the result of the R_MICROMIPS_HI16 being 0.  */
12536               nextopc &= ~0x001f0000;
12537               bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
12538                           contents + irel[1].r_offset);
12539             }
12540
12541           /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
12542              We add 4 to take LUI deletion into account while checking
12543              the PC-relative distance.  */
12544           else if (symval % 4 == 0
12545                    && IS_BITSIZE (pcrval + 4, 25)
12546                    && MATCH (nextopc, addiu_insn)
12547                    && OP32_TREG (nextopc) == OP32_SREG (nextopc)
12548                    && OP16_VALID_REG (OP32_TREG (nextopc)))
12549             {
12550               /* Fix the relocation's type.  */
12551               irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
12552
12553               /* Replace ADDIU with the ADDIUPC version.  */
12554               nextopc = (addiupc_insn.match
12555                          | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
12556
12557               bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
12558                           contents + irel[1].r_offset);
12559               bfd_put_16 (abfd,  nextopc        & 0xffff,
12560                           contents + irel[1].r_offset + 2);
12561             }
12562
12563           /* Can't do anything, give up, sigh...  */
12564           else
12565             continue;
12566
12567           /* Fix the relocation's type.  */
12568           irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
12569
12570           /* Delete the LUI instruction: 4 bytes at irel->r_offset.  */
12571           delcnt = 4;
12572           deloff = 0;
12573         }
12574
12575       /* Compact branch relaxation -- due to the multitude of macros
12576          employed by the compiler/assembler, compact branches are not
12577          always generated.  Obviously, this can/will be fixed elsewhere,
12578          but there is no drawback in double checking it here.  */
12579       else if (r_type == R_MICROMIPS_PC16_S1
12580                && irel->r_offset + 5 < sec->size
12581                && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12582                    || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
12583                && MATCH (bfd_get_16 (abfd, ptr + 4), nop_insn_16))
12584         {
12585           unsigned long reg;
12586
12587           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12588
12589           /* Replace BEQZ/BNEZ with the compact version.  */
12590           opcode = (bzc_insns_32[fndopc].match
12591                     | BZC32_REG_FIELD (reg)
12592                     | (opcode & 0xffff));               /* Addend value.  */
12593
12594           bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
12595           bfd_put_16 (abfd,  opcode        & 0xffff, ptr + 2);
12596
12597           /* Delete the 16-bit delay slot NOP: two bytes from
12598              irel->offset + 4.  */
12599           delcnt = 2;
12600           deloff = 4;
12601         }
12602
12603       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1.  We need
12604          to check the distance from the next instruction, so subtract 2.  */
12605       else if (r_type == R_MICROMIPS_PC16_S1
12606                && IS_BITSIZE (pcrval - 2, 11)
12607                && find_match (opcode, b_insns_32) >= 0)
12608         {
12609           /* Fix the relocation's type.  */
12610           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
12611
12612           /* Replace the the 32-bit opcode with a 16-bit opcode.  */
12613           bfd_put_16 (abfd,
12614                       (b_insn_16.match
12615                        | (opcode & 0x3ff)),             /* Addend value.  */
12616                       ptr);
12617
12618           /* Delete 2 bytes from irel->r_offset + 2.  */
12619           delcnt = 2;
12620           deloff = 2;
12621         }
12622
12623       /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1.  We need
12624          to check the distance from the next instruction, so subtract 2.  */
12625       else if (r_type == R_MICROMIPS_PC16_S1
12626                && IS_BITSIZE (pcrval - 2, 8)
12627                && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12628                     && OP16_VALID_REG (OP32_SREG (opcode)))
12629                    || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
12630                        && OP16_VALID_REG (OP32_TREG (opcode)))))
12631         {
12632           unsigned long reg;
12633
12634           reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12635
12636           /* Fix the relocation's type.  */
12637           irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
12638
12639           /* Replace the the 32-bit opcode with a 16-bit opcode.  */
12640           bfd_put_16 (abfd,
12641                       (bz_insns_16[fndopc].match
12642                        | BZ16_REG_FIELD (reg)
12643                        | (opcode & 0x7f)),              /* Addend value.  */
12644                       ptr);
12645
12646           /* Delete 2 bytes from irel->r_offset + 2.  */
12647           delcnt = 2;
12648           deloff = 2;
12649         }
12650
12651       /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets.  */
12652       else if (r_type == R_MICROMIPS_26_S1
12653                && target_is_micromips_code_p
12654                && irel->r_offset + 7 < sec->size
12655                && MATCH (opcode, jal_insn_32_bd32))
12656         {
12657           unsigned long n32opc;
12658           bfd_boolean relaxed = FALSE;
12659
12660           n32opc  = bfd_get_16 (abfd, ptr + 4) << 16;
12661           n32opc |= bfd_get_16 (abfd, ptr + 6);
12662
12663           if (MATCH (n32opc, nop_insn_32))
12664             {
12665               /* Replace delay slot 32-bit NOP with a 16-bit NOP.  */
12666               bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
12667
12668               relaxed = TRUE;
12669             }
12670           else if (find_match (n32opc, move_insns_32) >= 0)
12671             {
12672               /* Replace delay slot 32-bit MOVE with 16-bit MOVE.  */
12673               bfd_put_16 (abfd,
12674                           (move_insn_16.match
12675                            | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
12676                            | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
12677                           ptr + 4);
12678
12679               relaxed = TRUE;
12680             }
12681           /* Other 32-bit instructions relaxable to 16-bit
12682              instructions will be handled here later.  */
12683
12684           if (relaxed)
12685             {
12686               /* JAL with 32-bit delay slot that is changed to a JALS
12687                  with 16-bit delay slot.  */
12688               bfd_put_16 (abfd, (jal_insn_32_bd16.match >> 16) & 0xffff,
12689                           ptr);
12690               bfd_put_16 (abfd,  jal_insn_32_bd16.match        & 0xffff,
12691                           ptr + 2);
12692
12693               /* Delete 2 bytes from irel->r_offset + 6.  */
12694               delcnt = 2;
12695               deloff = 6;
12696             }
12697         }
12698
12699       if (delcnt != 0)
12700         {
12701           /* Note that we've changed the relocs, section contents, etc.  */
12702           elf_section_data (sec)->relocs = internal_relocs;
12703           elf_section_data (sec)->this_hdr.contents = contents;
12704           symtab_hdr->contents = (unsigned char *) isymbuf;
12705
12706           /* Delete bytes depending on the delcnt and deloff.  */
12707           if (!mips_elf_relax_delete_bytes (abfd, sec,
12708                                             irel->r_offset + deloff, delcnt))
12709             goto error_return;
12710
12711           /* That will change things, so we should relax again.
12712              Note that this is not required, and it may be slow.  */
12713           *again = TRUE;
12714         }
12715     }
12716
12717   if (isymbuf != NULL
12718       && symtab_hdr->contents != (unsigned char *) isymbuf)
12719     {
12720       if (! link_info->keep_memory)
12721         free (isymbuf);
12722       else
12723         {
12724           /* Cache the symbols for elf_link_input_bfd.  */
12725           symtab_hdr->contents = (unsigned char *) isymbuf;
12726         }
12727     }
12728
12729   if (contents != NULL
12730       && elf_section_data (sec)->this_hdr.contents != contents)
12731     {
12732       if (! link_info->keep_memory)
12733         free (contents);
12734       else
12735         {
12736           /* Cache the section contents for elf_link_input_bfd.  */
12737           elf_section_data (sec)->this_hdr.contents = contents;
12738         }
12739     }
12740
12741   if (internal_relocs != NULL
12742       && elf_section_data (sec)->relocs != internal_relocs)
12743     free (internal_relocs);
12744
12745   return TRUE;
12746
12747  error_return:
12748   if (isymbuf != NULL
12749       && symtab_hdr->contents != (unsigned char *) isymbuf)
12750     free (isymbuf);
12751   if (contents != NULL
12752       && elf_section_data (sec)->this_hdr.contents != contents)
12753     free (contents);
12754   if (internal_relocs != NULL
12755       && elf_section_data (sec)->relocs != internal_relocs)
12756     free (internal_relocs);
12757
12758   return FALSE;
12759 }
12760 \f
12761 /* Create a MIPS ELF linker hash table.  */
12762
12763 struct bfd_link_hash_table *
12764 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
12765 {
12766   struct mips_elf_link_hash_table *ret;
12767   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
12768
12769   ret = bfd_malloc (amt);
12770   if (ret == NULL)
12771     return NULL;
12772
12773   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
12774                                       mips_elf_link_hash_newfunc,
12775                                       sizeof (struct mips_elf_link_hash_entry),
12776                                       MIPS_ELF_DATA))
12777     {
12778       free (ret);
12779       return NULL;
12780     }
12781
12782 #if 0
12783   /* We no longer use this.  */
12784   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
12785     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
12786 #endif
12787   ret->procedure_count = 0;
12788   ret->compact_rel_size = 0;
12789   ret->use_rld_obj_head = FALSE;
12790   ret->rld_value = 0;
12791   ret->mips16_stubs_seen = FALSE;
12792   ret->use_plts_and_copy_relocs = FALSE;
12793   ret->is_vxworks = FALSE;
12794   ret->small_data_overflow_reported = FALSE;
12795   ret->srelbss = NULL;
12796   ret->sdynbss = NULL;
12797   ret->srelplt = NULL;
12798   ret->srelplt2 = NULL;
12799   ret->sgotplt = NULL;
12800   ret->splt = NULL;
12801   ret->sstubs = NULL;
12802   ret->sgot = NULL;
12803   ret->got_info = NULL;
12804   ret->plt_header_size = 0;
12805   ret->plt_entry_size = 0;
12806   ret->lazy_stub_count = 0;
12807   ret->function_stub_size = 0;
12808   ret->strampoline = NULL;
12809   ret->la25_stubs = NULL;
12810   ret->add_stub_section = NULL;
12811
12812   return &ret->root.root;
12813 }
12814
12815 /* Likewise, but indicate that the target is VxWorks.  */
12816
12817 struct bfd_link_hash_table *
12818 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
12819 {
12820   struct bfd_link_hash_table *ret;
12821
12822   ret = _bfd_mips_elf_link_hash_table_create (abfd);
12823   if (ret)
12824     {
12825       struct mips_elf_link_hash_table *htab;
12826
12827       htab = (struct mips_elf_link_hash_table *) ret;
12828       htab->use_plts_and_copy_relocs = TRUE;
12829       htab->is_vxworks = TRUE;
12830     }
12831   return ret;
12832 }
12833
12834 /* A function that the linker calls if we are allowed to use PLTs
12835    and copy relocs.  */
12836
12837 void
12838 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
12839 {
12840   mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
12841 }
12842 \f
12843 /* We need to use a special link routine to handle the .reginfo and
12844    the .mdebug sections.  We need to merge all instances of these
12845    sections together, not write them all out sequentially.  */
12846
12847 bfd_boolean
12848 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
12849 {
12850   asection *o;
12851   struct bfd_link_order *p;
12852   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
12853   asection *rtproc_sec;
12854   Elf32_RegInfo reginfo;
12855   struct ecoff_debug_info debug;
12856   struct mips_htab_traverse_info hti;
12857   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12858   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
12859   HDRR *symhdr = &debug.symbolic_header;
12860   void *mdebug_handle = NULL;
12861   asection *s;
12862   EXTR esym;
12863   unsigned int i;
12864   bfd_size_type amt;
12865   struct mips_elf_link_hash_table *htab;
12866
12867   static const char * const secname[] =
12868   {
12869     ".text", ".init", ".fini", ".data",
12870     ".rodata", ".sdata", ".sbss", ".bss"
12871   };
12872   static const int sc[] =
12873   {
12874     scText, scInit, scFini, scData,
12875     scRData, scSData, scSBss, scBss
12876   };
12877
12878   /* Sort the dynamic symbols so that those with GOT entries come after
12879      those without.  */
12880   htab = mips_elf_hash_table (info);
12881   BFD_ASSERT (htab != NULL);
12882
12883   if (!mips_elf_sort_hash_table (abfd, info))
12884     return FALSE;
12885
12886   /* Create any scheduled LA25 stubs.  */
12887   hti.info = info;
12888   hti.output_bfd = abfd;
12889   hti.error = FALSE;
12890   htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
12891   if (hti.error)
12892     return FALSE;
12893
12894   /* Get a value for the GP register.  */
12895   if (elf_gp (abfd) == 0)
12896     {
12897       struct bfd_link_hash_entry *h;
12898
12899       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
12900       if (h != NULL && h->type == bfd_link_hash_defined)
12901         elf_gp (abfd) = (h->u.def.value
12902                          + h->u.def.section->output_section->vma
12903                          + h->u.def.section->output_offset);
12904       else if (htab->is_vxworks
12905                && (h = bfd_link_hash_lookup (info->hash,
12906                                              "_GLOBAL_OFFSET_TABLE_",
12907                                              FALSE, FALSE, TRUE))
12908                && h->type == bfd_link_hash_defined)
12909         elf_gp (abfd) = (h->u.def.section->output_section->vma
12910                          + h->u.def.section->output_offset
12911                          + h->u.def.value);
12912       else if (info->relocatable)
12913         {
12914           bfd_vma lo = MINUS_ONE;
12915
12916           /* Find the GP-relative section with the lowest offset.  */
12917           for (o = abfd->sections; o != NULL; o = o->next)
12918             if (o->vma < lo
12919                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
12920               lo = o->vma;
12921
12922           /* And calculate GP relative to that.  */
12923           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
12924         }
12925       else
12926         {
12927           /* If the relocate_section function needs to do a reloc
12928              involving the GP value, it should make a reloc_dangerous
12929              callback to warn that GP is not defined.  */
12930         }
12931     }
12932
12933   /* Go through the sections and collect the .reginfo and .mdebug
12934      information.  */
12935   reginfo_sec = NULL;
12936   mdebug_sec = NULL;
12937   gptab_data_sec = NULL;
12938   gptab_bss_sec = NULL;
12939   for (o = abfd->sections; o != NULL; o = o->next)
12940     {
12941       if (strcmp (o->name, ".reginfo") == 0)
12942         {
12943           memset (&reginfo, 0, sizeof reginfo);
12944
12945           /* We have found the .reginfo section in the output file.
12946              Look through all the link_orders comprising it and merge
12947              the information together.  */
12948           for (p = o->map_head.link_order; p != NULL; p = p->next)
12949             {
12950               asection *input_section;
12951               bfd *input_bfd;
12952               Elf32_External_RegInfo ext;
12953               Elf32_RegInfo sub;
12954
12955               if (p->type != bfd_indirect_link_order)
12956                 {
12957                   if (p->type == bfd_data_link_order)
12958                     continue;
12959                   abort ();
12960                 }
12961
12962               input_section = p->u.indirect.section;
12963               input_bfd = input_section->owner;
12964
12965               if (! bfd_get_section_contents (input_bfd, input_section,
12966                                               &ext, 0, sizeof ext))
12967                 return FALSE;
12968
12969               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
12970
12971               reginfo.ri_gprmask |= sub.ri_gprmask;
12972               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
12973               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
12974               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
12975               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
12976
12977               /* ri_gp_value is set by the function
12978                  mips_elf32_section_processing when the section is
12979                  finally written out.  */
12980
12981               /* Hack: reset the SEC_HAS_CONTENTS flag so that
12982                  elf_link_input_bfd ignores this section.  */
12983               input_section->flags &= ~SEC_HAS_CONTENTS;
12984             }
12985
12986           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
12987           BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
12988
12989           /* Skip this section later on (I don't think this currently
12990              matters, but someday it might).  */
12991           o->map_head.link_order = NULL;
12992
12993           reginfo_sec = o;
12994         }
12995
12996       if (strcmp (o->name, ".mdebug") == 0)
12997         {
12998           struct extsym_info einfo;
12999           bfd_vma last;
13000
13001           /* We have found the .mdebug section in the output file.
13002              Look through all the link_orders comprising it and merge
13003              the information together.  */
13004           symhdr->magic = swap->sym_magic;
13005           /* FIXME: What should the version stamp be?  */
13006           symhdr->vstamp = 0;
13007           symhdr->ilineMax = 0;
13008           symhdr->cbLine = 0;
13009           symhdr->idnMax = 0;
13010           symhdr->ipdMax = 0;
13011           symhdr->isymMax = 0;
13012           symhdr->ioptMax = 0;
13013           symhdr->iauxMax = 0;
13014           symhdr->issMax = 0;
13015           symhdr->issExtMax = 0;
13016           symhdr->ifdMax = 0;
13017           symhdr->crfd = 0;
13018           symhdr->iextMax = 0;
13019
13020           /* We accumulate the debugging information itself in the
13021              debug_info structure.  */
13022           debug.line = NULL;
13023           debug.external_dnr = NULL;
13024           debug.external_pdr = NULL;
13025           debug.external_sym = NULL;
13026           debug.external_opt = NULL;
13027           debug.external_aux = NULL;
13028           debug.ss = NULL;
13029           debug.ssext = debug.ssext_end = NULL;
13030           debug.external_fdr = NULL;
13031           debug.external_rfd = NULL;
13032           debug.external_ext = debug.external_ext_end = NULL;
13033
13034           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
13035           if (mdebug_handle == NULL)
13036             return FALSE;
13037
13038           esym.jmptbl = 0;
13039           esym.cobol_main = 0;
13040           esym.weakext = 0;
13041           esym.reserved = 0;
13042           esym.ifd = ifdNil;
13043           esym.asym.iss = issNil;
13044           esym.asym.st = stLocal;
13045           esym.asym.reserved = 0;
13046           esym.asym.index = indexNil;
13047           last = 0;
13048           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
13049             {
13050               esym.asym.sc = sc[i];
13051               s = bfd_get_section_by_name (abfd, secname[i]);
13052               if (s != NULL)
13053                 {
13054                   esym.asym.value = s->vma;
13055                   last = s->vma + s->size;
13056                 }
13057               else
13058                 esym.asym.value = last;
13059               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
13060                                                  secname[i], &esym))
13061                 return FALSE;
13062             }
13063
13064           for (p = o->map_head.link_order; p != NULL; p = p->next)
13065             {
13066               asection *input_section;
13067               bfd *input_bfd;
13068               const struct ecoff_debug_swap *input_swap;
13069               struct ecoff_debug_info input_debug;
13070               char *eraw_src;
13071               char *eraw_end;
13072
13073               if (p->type != bfd_indirect_link_order)
13074                 {
13075                   if (p->type == bfd_data_link_order)
13076                     continue;
13077                   abort ();
13078                 }
13079
13080               input_section = p->u.indirect.section;
13081               input_bfd = input_section->owner;
13082
13083               if (!is_mips_elf (input_bfd))
13084                 {
13085                   /* I don't know what a non MIPS ELF bfd would be
13086                      doing with a .mdebug section, but I don't really
13087                      want to deal with it.  */
13088                   continue;
13089                 }
13090
13091               input_swap = (get_elf_backend_data (input_bfd)
13092                             ->elf_backend_ecoff_debug_swap);
13093
13094               BFD_ASSERT (p->size == input_section->size);
13095
13096               /* The ECOFF linking code expects that we have already
13097                  read in the debugging information and set up an
13098                  ecoff_debug_info structure, so we do that now.  */
13099               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
13100                                                    &input_debug))
13101                 return FALSE;
13102
13103               if (! (bfd_ecoff_debug_accumulate
13104                      (mdebug_handle, abfd, &debug, swap, input_bfd,
13105                       &input_debug, input_swap, info)))
13106                 return FALSE;
13107
13108               /* Loop through the external symbols.  For each one with
13109                  interesting information, try to find the symbol in
13110                  the linker global hash table and save the information
13111                  for the output external symbols.  */
13112               eraw_src = input_debug.external_ext;
13113               eraw_end = (eraw_src
13114                           + (input_debug.symbolic_header.iextMax
13115                              * input_swap->external_ext_size));
13116               for (;
13117                    eraw_src < eraw_end;
13118                    eraw_src += input_swap->external_ext_size)
13119                 {
13120                   EXTR ext;
13121                   const char *name;
13122                   struct mips_elf_link_hash_entry *h;
13123
13124                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
13125                   if (ext.asym.sc == scNil
13126                       || ext.asym.sc == scUndefined
13127                       || ext.asym.sc == scSUndefined)
13128                     continue;
13129
13130                   name = input_debug.ssext + ext.asym.iss;
13131                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
13132                                                  name, FALSE, FALSE, TRUE);
13133                   if (h == NULL || h->esym.ifd != -2)
13134                     continue;
13135
13136                   if (ext.ifd != -1)
13137                     {
13138                       BFD_ASSERT (ext.ifd
13139                                   < input_debug.symbolic_header.ifdMax);
13140                       ext.ifd = input_debug.ifdmap[ext.ifd];
13141                     }
13142
13143                   h->esym = ext;
13144                 }
13145
13146               /* Free up the information we just read.  */
13147               free (input_debug.line);
13148               free (input_debug.external_dnr);
13149               free (input_debug.external_pdr);
13150               free (input_debug.external_sym);
13151               free (input_debug.external_opt);
13152               free (input_debug.external_aux);
13153               free (input_debug.ss);
13154               free (input_debug.ssext);
13155               free (input_debug.external_fdr);
13156               free (input_debug.external_rfd);
13157               free (input_debug.external_ext);
13158
13159               /* Hack: reset the SEC_HAS_CONTENTS flag so that
13160                  elf_link_input_bfd ignores this section.  */
13161               input_section->flags &= ~SEC_HAS_CONTENTS;
13162             }
13163
13164           if (SGI_COMPAT (abfd) && info->shared)
13165             {
13166               /* Create .rtproc section.  */
13167               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
13168               if (rtproc_sec == NULL)
13169                 {
13170                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
13171                                     | SEC_LINKER_CREATED | SEC_READONLY);
13172
13173                   rtproc_sec = bfd_make_section_with_flags (abfd,
13174                                                             ".rtproc",
13175                                                             flags);
13176                   if (rtproc_sec == NULL
13177                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
13178                     return FALSE;
13179                 }
13180
13181               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
13182                                                      info, rtproc_sec,
13183                                                      &debug))
13184                 return FALSE;
13185             }
13186
13187           /* Build the external symbol information.  */
13188           einfo.abfd = abfd;
13189           einfo.info = info;
13190           einfo.debug = &debug;
13191           einfo.swap = swap;
13192           einfo.failed = FALSE;
13193           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
13194                                        mips_elf_output_extsym, &einfo);
13195           if (einfo.failed)
13196             return FALSE;
13197
13198           /* Set the size of the .mdebug section.  */
13199           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
13200
13201           /* Skip this section later on (I don't think this currently
13202              matters, but someday it might).  */
13203           o->map_head.link_order = NULL;
13204
13205           mdebug_sec = o;
13206         }
13207
13208       if (CONST_STRNEQ (o->name, ".gptab."))
13209         {
13210           const char *subname;
13211           unsigned int c;
13212           Elf32_gptab *tab;
13213           Elf32_External_gptab *ext_tab;
13214           unsigned int j;
13215
13216           /* The .gptab.sdata and .gptab.sbss sections hold
13217              information describing how the small data area would
13218              change depending upon the -G switch.  These sections
13219              not used in executables files.  */
13220           if (! info->relocatable)
13221             {
13222               for (p = o->map_head.link_order; p != NULL; p = p->next)
13223                 {
13224                   asection *input_section;
13225
13226                   if (p->type != bfd_indirect_link_order)
13227                     {
13228                       if (p->type == bfd_data_link_order)
13229                         continue;
13230                       abort ();
13231                     }
13232
13233                   input_section = p->u.indirect.section;
13234
13235                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
13236                      elf_link_input_bfd ignores this section.  */
13237                   input_section->flags &= ~SEC_HAS_CONTENTS;
13238                 }
13239
13240               /* Skip this section later on (I don't think this
13241                  currently matters, but someday it might).  */
13242               o->map_head.link_order = NULL;
13243
13244               /* Really remove the section.  */
13245               bfd_section_list_remove (abfd, o);
13246               --abfd->section_count;
13247
13248               continue;
13249             }
13250
13251           /* There is one gptab for initialized data, and one for
13252              uninitialized data.  */
13253           if (strcmp (o->name, ".gptab.sdata") == 0)
13254             gptab_data_sec = o;
13255           else if (strcmp (o->name, ".gptab.sbss") == 0)
13256             gptab_bss_sec = o;
13257           else
13258             {
13259               (*_bfd_error_handler)
13260                 (_("%s: illegal section name `%s'"),
13261                  bfd_get_filename (abfd), o->name);
13262               bfd_set_error (bfd_error_nonrepresentable_section);
13263               return FALSE;
13264             }
13265
13266           /* The linker script always combines .gptab.data and
13267              .gptab.sdata into .gptab.sdata, and likewise for
13268              .gptab.bss and .gptab.sbss.  It is possible that there is
13269              no .sdata or .sbss section in the output file, in which
13270              case we must change the name of the output section.  */
13271           subname = o->name + sizeof ".gptab" - 1;
13272           if (bfd_get_section_by_name (abfd, subname) == NULL)
13273             {
13274               if (o == gptab_data_sec)
13275                 o->name = ".gptab.data";
13276               else
13277                 o->name = ".gptab.bss";
13278               subname = o->name + sizeof ".gptab" - 1;
13279               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
13280             }
13281
13282           /* Set up the first entry.  */
13283           c = 1;
13284           amt = c * sizeof (Elf32_gptab);
13285           tab = bfd_malloc (amt);
13286           if (tab == NULL)
13287             return FALSE;
13288           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
13289           tab[0].gt_header.gt_unused = 0;
13290
13291           /* Combine the input sections.  */
13292           for (p = o->map_head.link_order; p != NULL; p = p->next)
13293             {
13294               asection *input_section;
13295               bfd *input_bfd;
13296               bfd_size_type size;
13297               unsigned long last;
13298               bfd_size_type gpentry;
13299
13300               if (p->type != bfd_indirect_link_order)
13301                 {
13302                   if (p->type == bfd_data_link_order)
13303                     continue;
13304                   abort ();
13305                 }
13306
13307               input_section = p->u.indirect.section;
13308               input_bfd = input_section->owner;
13309
13310               /* Combine the gptab entries for this input section one
13311                  by one.  We know that the input gptab entries are
13312                  sorted by ascending -G value.  */
13313               size = input_section->size;
13314               last = 0;
13315               for (gpentry = sizeof (Elf32_External_gptab);
13316                    gpentry < size;
13317                    gpentry += sizeof (Elf32_External_gptab))
13318                 {
13319                   Elf32_External_gptab ext_gptab;
13320                   Elf32_gptab int_gptab;
13321                   unsigned long val;
13322                   unsigned long add;
13323                   bfd_boolean exact;
13324                   unsigned int look;
13325
13326                   if (! (bfd_get_section_contents
13327                          (input_bfd, input_section, &ext_gptab, gpentry,
13328                           sizeof (Elf32_External_gptab))))
13329                     {
13330                       free (tab);
13331                       return FALSE;
13332                     }
13333
13334                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
13335                                                 &int_gptab);
13336                   val = int_gptab.gt_entry.gt_g_value;
13337                   add = int_gptab.gt_entry.gt_bytes - last;
13338
13339                   exact = FALSE;
13340                   for (look = 1; look < c; look++)
13341                     {
13342                       if (tab[look].gt_entry.gt_g_value >= val)
13343                         tab[look].gt_entry.gt_bytes += add;
13344
13345                       if (tab[look].gt_entry.gt_g_value == val)
13346                         exact = TRUE;
13347                     }
13348
13349                   if (! exact)
13350                     {
13351                       Elf32_gptab *new_tab;
13352                       unsigned int max;
13353
13354                       /* We need a new table entry.  */
13355                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
13356                       new_tab = bfd_realloc (tab, amt);
13357                       if (new_tab == NULL)
13358                         {
13359                           free (tab);
13360                           return FALSE;
13361                         }
13362                       tab = new_tab;
13363                       tab[c].gt_entry.gt_g_value = val;
13364                       tab[c].gt_entry.gt_bytes = add;
13365
13366                       /* Merge in the size for the next smallest -G
13367                          value, since that will be implied by this new
13368                          value.  */
13369                       max = 0;
13370                       for (look = 1; look < c; look++)
13371                         {
13372                           if (tab[look].gt_entry.gt_g_value < val
13373                               && (max == 0
13374                                   || (tab[look].gt_entry.gt_g_value
13375                                       > tab[max].gt_entry.gt_g_value)))
13376                             max = look;
13377                         }
13378                       if (max != 0)
13379                         tab[c].gt_entry.gt_bytes +=
13380                           tab[max].gt_entry.gt_bytes;
13381
13382                       ++c;
13383                     }
13384
13385                   last = int_gptab.gt_entry.gt_bytes;
13386                 }
13387
13388               /* Hack: reset the SEC_HAS_CONTENTS flag so that
13389                  elf_link_input_bfd ignores this section.  */
13390               input_section->flags &= ~SEC_HAS_CONTENTS;
13391             }
13392
13393           /* The table must be sorted by -G value.  */
13394           if (c > 2)
13395             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
13396
13397           /* Swap out the table.  */
13398           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
13399           ext_tab = bfd_alloc (abfd, amt);
13400           if (ext_tab == NULL)
13401             {
13402               free (tab);
13403               return FALSE;
13404             }
13405
13406           for (j = 0; j < c; j++)
13407             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
13408           free (tab);
13409
13410           o->size = c * sizeof (Elf32_External_gptab);
13411           o->contents = (bfd_byte *) ext_tab;
13412
13413           /* Skip this section later on (I don't think this currently
13414              matters, but someday it might).  */
13415           o->map_head.link_order = NULL;
13416         }
13417     }
13418
13419   /* Invoke the regular ELF backend linker to do all the work.  */
13420   if (!bfd_elf_final_link (abfd, info))
13421     return FALSE;
13422
13423   /* Now write out the computed sections.  */
13424
13425   if (reginfo_sec != NULL)
13426     {
13427       Elf32_External_RegInfo ext;
13428
13429       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
13430       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
13431         return FALSE;
13432     }
13433
13434   if (mdebug_sec != NULL)
13435     {
13436       BFD_ASSERT (abfd->output_has_begun);
13437       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
13438                                                swap, info,
13439                                                mdebug_sec->filepos))
13440         return FALSE;
13441
13442       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
13443     }
13444
13445   if (gptab_data_sec != NULL)
13446     {
13447       if (! bfd_set_section_contents (abfd, gptab_data_sec,
13448                                       gptab_data_sec->contents,
13449                                       0, gptab_data_sec->size))
13450         return FALSE;
13451     }
13452
13453   if (gptab_bss_sec != NULL)
13454     {
13455       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
13456                                       gptab_bss_sec->contents,
13457                                       0, gptab_bss_sec->size))
13458         return FALSE;
13459     }
13460
13461   if (SGI_COMPAT (abfd))
13462     {
13463       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
13464       if (rtproc_sec != NULL)
13465         {
13466           if (! bfd_set_section_contents (abfd, rtproc_sec,
13467                                           rtproc_sec->contents,
13468                                           0, rtproc_sec->size))
13469             return FALSE;
13470         }
13471     }
13472
13473   return TRUE;
13474 }
13475 \f
13476 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
13477
13478 struct mips_mach_extension {
13479   unsigned long extension, base;
13480 };
13481
13482
13483 /* An array describing how BFD machines relate to one another.  The entries
13484    are ordered topologically with MIPS I extensions listed last.  */
13485
13486 static const struct mips_mach_extension mips_mach_extensions[] = {
13487   /* MIPS64r2 extensions.  */
13488   { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
13489
13490   /* MIPS64 extensions.  */
13491   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
13492   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
13493   { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
13494   { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64 },
13495
13496   /* MIPS V extensions.  */
13497   { bfd_mach_mipsisa64, bfd_mach_mips5 },
13498
13499   /* R10000 extensions.  */
13500   { bfd_mach_mips12000, bfd_mach_mips10000 },
13501   { bfd_mach_mips14000, bfd_mach_mips10000 },
13502   { bfd_mach_mips16000, bfd_mach_mips10000 },
13503
13504   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
13505      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
13506      better to allow vr5400 and vr5500 code to be merged anyway, since
13507      many libraries will just use the core ISA.  Perhaps we could add
13508      some sort of ASE flag if this ever proves a problem.  */
13509   { bfd_mach_mips5500, bfd_mach_mips5400 },
13510   { bfd_mach_mips5400, bfd_mach_mips5000 },
13511
13512   /* MIPS IV extensions.  */
13513   { bfd_mach_mips5, bfd_mach_mips8000 },
13514   { bfd_mach_mips10000, bfd_mach_mips8000 },
13515   { bfd_mach_mips5000, bfd_mach_mips8000 },
13516   { bfd_mach_mips7000, bfd_mach_mips8000 },
13517   { bfd_mach_mips9000, bfd_mach_mips8000 },
13518
13519   /* VR4100 extensions.  */
13520   { bfd_mach_mips4120, bfd_mach_mips4100 },
13521   { bfd_mach_mips4111, bfd_mach_mips4100 },
13522
13523   /* MIPS III extensions.  */
13524   { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
13525   { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
13526   { bfd_mach_mips8000, bfd_mach_mips4000 },
13527   { bfd_mach_mips4650, bfd_mach_mips4000 },
13528   { bfd_mach_mips4600, bfd_mach_mips4000 },
13529   { bfd_mach_mips4400, bfd_mach_mips4000 },
13530   { bfd_mach_mips4300, bfd_mach_mips4000 },
13531   { bfd_mach_mips4100, bfd_mach_mips4000 },
13532   { bfd_mach_mips4010, bfd_mach_mips4000 },
13533
13534   /* MIPS32 extensions.  */
13535   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
13536
13537   /* MIPS II extensions.  */
13538   { bfd_mach_mips4000, bfd_mach_mips6000 },
13539   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
13540
13541   /* MIPS I extensions.  */
13542   { bfd_mach_mips6000, bfd_mach_mips3000 },
13543   { bfd_mach_mips3900, bfd_mach_mips3000 }
13544 };
13545
13546
13547 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
13548
13549 static bfd_boolean
13550 mips_mach_extends_p (unsigned long base, unsigned long extension)
13551 {
13552   size_t i;
13553
13554   if (extension == base)
13555     return TRUE;
13556
13557   if (base == bfd_mach_mipsisa32
13558       && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
13559     return TRUE;
13560
13561   if (base == bfd_mach_mipsisa32r2
13562       && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
13563     return TRUE;
13564
13565   for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
13566     if (extension == mips_mach_extensions[i].extension)
13567       {
13568         extension = mips_mach_extensions[i].base;
13569         if (extension == base)
13570           return TRUE;
13571       }
13572
13573   return FALSE;
13574 }
13575
13576
13577 /* Return true if the given ELF header flags describe a 32-bit binary.  */
13578
13579 static bfd_boolean
13580 mips_32bit_flags_p (flagword flags)
13581 {
13582   return ((flags & EF_MIPS_32BITMODE) != 0
13583           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
13584           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
13585           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
13586           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
13587           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
13588           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
13589 }
13590
13591
13592 /* Merge object attributes from IBFD into OBFD.  Raise an error if
13593    there are conflicting attributes.  */
13594 static bfd_boolean
13595 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
13596 {
13597   obj_attribute *in_attr;
13598   obj_attribute *out_attr;
13599
13600   if (!elf_known_obj_attributes_proc (obfd)[0].i)
13601     {
13602       /* This is the first object.  Copy the attributes.  */
13603       _bfd_elf_copy_obj_attributes (ibfd, obfd);
13604
13605       /* Use the Tag_null value to indicate the attributes have been
13606          initialized.  */
13607       elf_known_obj_attributes_proc (obfd)[0].i = 1;
13608
13609       return TRUE;
13610     }
13611
13612   /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
13613      non-conflicting ones.  */
13614   in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
13615   out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
13616   if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
13617     {
13618       out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
13619       if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13620         out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
13621       else if (in_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13622         ;
13623       else if (in_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
13624         _bfd_error_handler
13625           (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
13626            in_attr[Tag_GNU_MIPS_ABI_FP].i);
13627       else if (out_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
13628         _bfd_error_handler
13629           (_("Warning: %B uses unknown floating point ABI %d"), obfd,
13630            out_attr[Tag_GNU_MIPS_ABI_FP].i);
13631       else
13632         switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
13633           {
13634           case 1:
13635             switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13636               {
13637               case 2:
13638                 _bfd_error_handler
13639                   (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
13640                    obfd, ibfd);
13641                 break;
13642
13643               case 3:
13644                 _bfd_error_handler
13645                   (_("Warning: %B uses hard float, %B uses soft float"),
13646                    obfd, ibfd);
13647                 break;
13648
13649               case 4:
13650                 _bfd_error_handler
13651                   (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
13652                    obfd, ibfd);
13653                 break;
13654
13655               default:
13656                 abort ();
13657               }
13658             break;
13659
13660           case 2:
13661             switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13662               {
13663               case 1:
13664                 _bfd_error_handler
13665                   (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
13666                    ibfd, obfd);
13667                 break;
13668
13669               case 3:
13670                 _bfd_error_handler
13671                   (_("Warning: %B uses hard float, %B uses soft float"),
13672                    obfd, ibfd);
13673                 break;
13674
13675               case 4:
13676                 _bfd_error_handler
13677                   (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
13678                    obfd, ibfd);
13679                 break;
13680
13681               default:
13682                 abort ();
13683               }
13684             break;
13685
13686           case 3:
13687             switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13688               {
13689               case 1:
13690               case 2:
13691               case 4:
13692                 _bfd_error_handler
13693                   (_("Warning: %B uses hard float, %B uses soft float"),
13694                    ibfd, obfd);
13695                 break;
13696
13697               default:
13698                 abort ();
13699               }
13700             break;
13701
13702           case 4:
13703             switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13704               {
13705               case 1:
13706                 _bfd_error_handler
13707                   (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
13708                    ibfd, obfd);
13709                 break;
13710
13711               case 2:
13712                 _bfd_error_handler
13713                   (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
13714                    ibfd, obfd);
13715                 break;
13716
13717               case 3:
13718                 _bfd_error_handler
13719                   (_("Warning: %B uses hard float, %B uses soft float"),
13720                    obfd, ibfd);
13721                 break;
13722
13723               default:
13724                 abort ();
13725               }
13726             break;
13727
13728           default:
13729             abort ();
13730           }
13731     }
13732
13733   /* Merge Tag_compatibility attributes and any common GNU ones.  */
13734   _bfd_elf_merge_object_attributes (ibfd, obfd);
13735
13736   return TRUE;
13737 }
13738
13739 /* Merge backend specific data from an object file to the output
13740    object file when linking.  */
13741
13742 bfd_boolean
13743 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
13744 {
13745   flagword old_flags;
13746   flagword new_flags;
13747   bfd_boolean ok;
13748   bfd_boolean null_input_bfd = TRUE;
13749   asection *sec;
13750
13751   /* Check if we have the same endianness.  */
13752   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
13753     {
13754       (*_bfd_error_handler)
13755         (_("%B: endianness incompatible with that of the selected emulation"),
13756          ibfd);
13757       return FALSE;
13758     }
13759
13760   if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
13761     return TRUE;
13762
13763   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
13764     {
13765       (*_bfd_error_handler)
13766         (_("%B: ABI is incompatible with that of the selected emulation"),
13767          ibfd);
13768       return FALSE;
13769     }
13770
13771   if (!mips_elf_merge_obj_attributes (ibfd, obfd))
13772     return FALSE;
13773
13774   new_flags = elf_elfheader (ibfd)->e_flags;
13775   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
13776   old_flags = elf_elfheader (obfd)->e_flags;
13777
13778   if (! elf_flags_init (obfd))
13779     {
13780       elf_flags_init (obfd) = TRUE;
13781       elf_elfheader (obfd)->e_flags = new_flags;
13782       elf_elfheader (obfd)->e_ident[EI_CLASS]
13783         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
13784
13785       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
13786           && (bfd_get_arch_info (obfd)->the_default
13787               || mips_mach_extends_p (bfd_get_mach (obfd),
13788                                       bfd_get_mach (ibfd))))
13789         {
13790           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
13791                                    bfd_get_mach (ibfd)))
13792             return FALSE;
13793         }
13794
13795       return TRUE;
13796     }
13797
13798   /* Check flag compatibility.  */
13799
13800   new_flags &= ~EF_MIPS_NOREORDER;
13801   old_flags &= ~EF_MIPS_NOREORDER;
13802
13803   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
13804      doesn't seem to matter.  */
13805   new_flags &= ~EF_MIPS_XGOT;
13806   old_flags &= ~EF_MIPS_XGOT;
13807
13808   /* MIPSpro generates ucode info in n64 objects.  Again, we should
13809      just be able to ignore this.  */
13810   new_flags &= ~EF_MIPS_UCODE;
13811   old_flags &= ~EF_MIPS_UCODE;
13812
13813   /* DSOs should only be linked with CPIC code.  */
13814   if ((ibfd->flags & DYNAMIC) != 0)
13815     new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
13816
13817   if (new_flags == old_flags)
13818     return TRUE;
13819
13820   /* Check to see if the input BFD actually contains any sections.
13821      If not, its flags may not have been initialised either, but it cannot
13822      actually cause any incompatibility.  */
13823   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
13824     {
13825       /* Ignore synthetic sections and empty .text, .data and .bss sections
13826          which are automatically generated by gas.  Also ignore fake
13827          (s)common sections, since merely defining a common symbol does
13828          not affect compatibility.  */
13829       if ((sec->flags & SEC_IS_COMMON) == 0
13830           && strcmp (sec->name, ".reginfo")
13831           && strcmp (sec->name, ".mdebug")
13832           && (sec->size != 0
13833               || (strcmp (sec->name, ".text")
13834                   && strcmp (sec->name, ".data")
13835                   && strcmp (sec->name, ".bss"))))
13836         {
13837           null_input_bfd = FALSE;
13838           break;
13839         }
13840     }
13841   if (null_input_bfd)
13842     return TRUE;
13843
13844   ok = TRUE;
13845
13846   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
13847       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
13848     {
13849       (*_bfd_error_handler)
13850         (_("%B: warning: linking abicalls files with non-abicalls files"),
13851          ibfd);
13852       ok = TRUE;
13853     }
13854
13855   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
13856     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
13857   if (! (new_flags & EF_MIPS_PIC))
13858     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
13859
13860   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
13861   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
13862
13863   /* Compare the ISAs.  */
13864   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
13865     {
13866       (*_bfd_error_handler)
13867         (_("%B: linking 32-bit code with 64-bit code"),
13868          ibfd);
13869       ok = FALSE;
13870     }
13871   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
13872     {
13873       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
13874       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
13875         {
13876           /* Copy the architecture info from IBFD to OBFD.  Also copy
13877              the 32-bit flag (if set) so that we continue to recognise
13878              OBFD as a 32-bit binary.  */
13879           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
13880           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
13881           elf_elfheader (obfd)->e_flags
13882             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
13883
13884           /* Copy across the ABI flags if OBFD doesn't use them
13885              and if that was what caused us to treat IBFD as 32-bit.  */
13886           if ((old_flags & EF_MIPS_ABI) == 0
13887               && mips_32bit_flags_p (new_flags)
13888               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
13889             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
13890         }
13891       else
13892         {
13893           /* The ISAs aren't compatible.  */
13894           (*_bfd_error_handler)
13895             (_("%B: linking %s module with previous %s modules"),
13896              ibfd,
13897              bfd_printable_name (ibfd),
13898              bfd_printable_name (obfd));
13899           ok = FALSE;
13900         }
13901     }
13902
13903   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
13904   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
13905
13906   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
13907      does set EI_CLASS differently from any 32-bit ABI.  */
13908   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
13909       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
13910           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
13911     {
13912       /* Only error if both are set (to different values).  */
13913       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
13914           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
13915               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
13916         {
13917           (*_bfd_error_handler)
13918             (_("%B: ABI mismatch: linking %s module with previous %s modules"),
13919              ibfd,
13920              elf_mips_abi_name (ibfd),
13921              elf_mips_abi_name (obfd));
13922           ok = FALSE;
13923         }
13924       new_flags &= ~EF_MIPS_ABI;
13925       old_flags &= ~EF_MIPS_ABI;
13926     }
13927
13928   /* Compare ASEs.  Forbid linking MIPS16 and microMIPS ASE modules together
13929      and allow arbitrary mixing of the remaining ASEs (retain the union).  */
13930   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
13931     {
13932       int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
13933       int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
13934       int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
13935       int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
13936       int micro_mis = old_m16 && new_micro;
13937       int m16_mis = old_micro && new_m16;
13938
13939       if (m16_mis || micro_mis)
13940         {
13941           (*_bfd_error_handler)
13942             (_("%B: ASE mismatch: linking %s module with previous %s modules"),
13943              ibfd,
13944              m16_mis ? "MIPS16" : "microMIPS",
13945              m16_mis ? "microMIPS" : "MIPS16");
13946           ok = FALSE;
13947         }
13948
13949       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
13950
13951       new_flags &= ~ EF_MIPS_ARCH_ASE;
13952       old_flags &= ~ EF_MIPS_ARCH_ASE;
13953     }
13954
13955   /* Warn about any other mismatches */
13956   if (new_flags != old_flags)
13957     {
13958       (*_bfd_error_handler)
13959         (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
13960          ibfd, (unsigned long) new_flags,
13961          (unsigned long) old_flags);
13962       ok = FALSE;
13963     }
13964
13965   if (! ok)
13966     {
13967       bfd_set_error (bfd_error_bad_value);
13968       return FALSE;
13969     }
13970
13971   return TRUE;
13972 }
13973
13974 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
13975
13976 bfd_boolean
13977 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
13978 {
13979   BFD_ASSERT (!elf_flags_init (abfd)
13980               || elf_elfheader (abfd)->e_flags == flags);
13981
13982   elf_elfheader (abfd)->e_flags = flags;
13983   elf_flags_init (abfd) = TRUE;
13984   return TRUE;
13985 }
13986
13987 char *
13988 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
13989 {
13990   switch (dtag)
13991     {
13992     default: return "";
13993     case DT_MIPS_RLD_VERSION:
13994       return "MIPS_RLD_VERSION";
13995     case DT_MIPS_TIME_STAMP:
13996       return "MIPS_TIME_STAMP";
13997     case DT_MIPS_ICHECKSUM:
13998       return "MIPS_ICHECKSUM";
13999     case DT_MIPS_IVERSION:
14000       return "MIPS_IVERSION";
14001     case DT_MIPS_FLAGS:
14002       return "MIPS_FLAGS";
14003     case DT_MIPS_BASE_ADDRESS:
14004       return "MIPS_BASE_ADDRESS";
14005     case DT_MIPS_MSYM:
14006       return "MIPS_MSYM";
14007     case DT_MIPS_CONFLICT:
14008       return "MIPS_CONFLICT";
14009     case DT_MIPS_LIBLIST:
14010       return "MIPS_LIBLIST";
14011     case DT_MIPS_LOCAL_GOTNO:
14012       return "MIPS_LOCAL_GOTNO";
14013     case DT_MIPS_CONFLICTNO:
14014       return "MIPS_CONFLICTNO";
14015     case DT_MIPS_LIBLISTNO:
14016       return "MIPS_LIBLISTNO";
14017     case DT_MIPS_SYMTABNO:
14018       return "MIPS_SYMTABNO";
14019     case DT_MIPS_UNREFEXTNO:
14020       return "MIPS_UNREFEXTNO";
14021     case DT_MIPS_GOTSYM:
14022       return "MIPS_GOTSYM";
14023     case DT_MIPS_HIPAGENO:
14024       return "MIPS_HIPAGENO";
14025     case DT_MIPS_RLD_MAP:
14026       return "MIPS_RLD_MAP";
14027     case DT_MIPS_DELTA_CLASS:
14028       return "MIPS_DELTA_CLASS";
14029     case DT_MIPS_DELTA_CLASS_NO:
14030       return "MIPS_DELTA_CLASS_NO";
14031     case DT_MIPS_DELTA_INSTANCE:
14032       return "MIPS_DELTA_INSTANCE";
14033     case DT_MIPS_DELTA_INSTANCE_NO:
14034       return "MIPS_DELTA_INSTANCE_NO";
14035     case DT_MIPS_DELTA_RELOC:
14036       return "MIPS_DELTA_RELOC";
14037     case DT_MIPS_DELTA_RELOC_NO:
14038       return "MIPS_DELTA_RELOC_NO";
14039     case DT_MIPS_DELTA_SYM:
14040       return "MIPS_DELTA_SYM";
14041     case DT_MIPS_DELTA_SYM_NO:
14042       return "MIPS_DELTA_SYM_NO";
14043     case DT_MIPS_DELTA_CLASSSYM:
14044       return "MIPS_DELTA_CLASSSYM";
14045     case DT_MIPS_DELTA_CLASSSYM_NO:
14046       return "MIPS_DELTA_CLASSSYM_NO";
14047     case DT_MIPS_CXX_FLAGS:
14048       return "MIPS_CXX_FLAGS";
14049     case DT_MIPS_PIXIE_INIT:
14050       return "MIPS_PIXIE_INIT";
14051     case DT_MIPS_SYMBOL_LIB:
14052       return "MIPS_SYMBOL_LIB";
14053     case DT_MIPS_LOCALPAGE_GOTIDX:
14054       return "MIPS_LOCALPAGE_GOTIDX";
14055     case DT_MIPS_LOCAL_GOTIDX:
14056       return "MIPS_LOCAL_GOTIDX";
14057     case DT_MIPS_HIDDEN_GOTIDX:
14058       return "MIPS_HIDDEN_GOTIDX";
14059     case DT_MIPS_PROTECTED_GOTIDX:
14060       return "MIPS_PROTECTED_GOT_IDX";
14061     case DT_MIPS_OPTIONS:
14062       return "MIPS_OPTIONS";
14063     case DT_MIPS_INTERFACE:
14064       return "MIPS_INTERFACE";
14065     case DT_MIPS_DYNSTR_ALIGN:
14066       return "DT_MIPS_DYNSTR_ALIGN";
14067     case DT_MIPS_INTERFACE_SIZE:
14068       return "DT_MIPS_INTERFACE_SIZE";
14069     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
14070       return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
14071     case DT_MIPS_PERF_SUFFIX:
14072       return "DT_MIPS_PERF_SUFFIX";
14073     case DT_MIPS_COMPACT_SIZE:
14074       return "DT_MIPS_COMPACT_SIZE";
14075     case DT_MIPS_GP_VALUE:
14076       return "DT_MIPS_GP_VALUE";
14077     case DT_MIPS_AUX_DYNAMIC:
14078       return "DT_MIPS_AUX_DYNAMIC";
14079     case DT_MIPS_PLTGOT:
14080       return "DT_MIPS_PLTGOT";
14081     case DT_MIPS_RWPLT:
14082       return "DT_MIPS_RWPLT";
14083     }
14084 }
14085
14086 bfd_boolean
14087 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
14088 {
14089   FILE *file = ptr;
14090
14091   BFD_ASSERT (abfd != NULL && ptr != NULL);
14092
14093   /* Print normal ELF private data.  */
14094   _bfd_elf_print_private_bfd_data (abfd, ptr);
14095
14096   /* xgettext:c-format */
14097   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
14098
14099   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
14100     fprintf (file, _(" [abi=O32]"));
14101   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
14102     fprintf (file, _(" [abi=O64]"));
14103   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
14104     fprintf (file, _(" [abi=EABI32]"));
14105   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
14106     fprintf (file, _(" [abi=EABI64]"));
14107   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
14108     fprintf (file, _(" [abi unknown]"));
14109   else if (ABI_N32_P (abfd))
14110     fprintf (file, _(" [abi=N32]"));
14111   else if (ABI_64_P (abfd))
14112     fprintf (file, _(" [abi=64]"));
14113   else
14114     fprintf (file, _(" [no abi set]"));
14115
14116   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
14117     fprintf (file, " [mips1]");
14118   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
14119     fprintf (file, " [mips2]");
14120   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
14121     fprintf (file, " [mips3]");
14122   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
14123     fprintf (file, " [mips4]");
14124   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
14125     fprintf (file, " [mips5]");
14126   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
14127     fprintf (file, " [mips32]");
14128   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
14129     fprintf (file, " [mips64]");
14130   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
14131     fprintf (file, " [mips32r2]");
14132   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
14133     fprintf (file, " [mips64r2]");
14134   else
14135     fprintf (file, _(" [unknown ISA]"));
14136
14137   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14138     fprintf (file, " [mdmx]");
14139
14140   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14141     fprintf (file, " [mips16]");
14142
14143   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14144     fprintf (file, " [micromips]");
14145
14146   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
14147     fprintf (file, " [32bitmode]");
14148   else
14149     fprintf (file, _(" [not 32bitmode]"));
14150
14151   if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
14152     fprintf (file, " [noreorder]");
14153
14154   if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
14155     fprintf (file, " [PIC]");
14156
14157   if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
14158     fprintf (file, " [CPIC]");
14159
14160   if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
14161     fprintf (file, " [XGOT]");
14162
14163   if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
14164     fprintf (file, " [UCODE]");
14165
14166   fputc ('\n', file);
14167
14168   return TRUE;
14169 }
14170
14171 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
14172 {
14173   { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14174   { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14175   { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
14176   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14177   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14178   { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
14179   { NULL,                     0,  0, 0,              0 }
14180 };
14181
14182 /* Merge non visibility st_other attributes.  Ensure that the
14183    STO_OPTIONAL flag is copied into h->other, even if this is not a
14184    definiton of the symbol.  */
14185 void
14186 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
14187                                       const Elf_Internal_Sym *isym,
14188                                       bfd_boolean definition,
14189                                       bfd_boolean dynamic ATTRIBUTE_UNUSED)
14190 {
14191   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
14192     {
14193       unsigned char other;
14194
14195       other = (definition ? isym->st_other : h->other);
14196       other &= ~ELF_ST_VISIBILITY (-1);
14197       h->other = other | ELF_ST_VISIBILITY (h->other);
14198     }
14199
14200   if (!definition
14201       && ELF_MIPS_IS_OPTIONAL (isym->st_other))
14202     h->other |= STO_OPTIONAL;
14203 }
14204
14205 /* Decide whether an undefined symbol is special and can be ignored.
14206    This is the case for OPTIONAL symbols on IRIX.  */
14207 bfd_boolean
14208 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
14209 {
14210   return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
14211 }
14212
14213 bfd_boolean
14214 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
14215 {
14216   return (sym->st_shndx == SHN_COMMON
14217           || sym->st_shndx == SHN_MIPS_ACOMMON
14218           || sym->st_shndx == SHN_MIPS_SCOMMON);
14219 }
14220
14221 /* Return address for Ith PLT stub in section PLT, for relocation REL
14222    or (bfd_vma) -1 if it should not be included.  */
14223
14224 bfd_vma
14225 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
14226                            const arelent *rel ATTRIBUTE_UNUSED)
14227 {
14228   return (plt->vma
14229           + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
14230           + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
14231 }
14232
14233 void
14234 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
14235 {
14236   struct mips_elf_link_hash_table *htab;
14237   Elf_Internal_Ehdr *i_ehdrp;
14238
14239   i_ehdrp = elf_elfheader (abfd);
14240   if (link_info)
14241     {
14242       htab = mips_elf_hash_table (link_info);
14243       BFD_ASSERT (htab != NULL);
14244
14245       if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
14246         i_ehdrp->e_ident[EI_ABIVERSION] = 1;
14247     }
14248 }