bfd/elf64-mips.c

   1 /* MIPS-specific support for 64-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4    Ian Lance Taylor, Cygnus Support
   5    Linker support added by Mark Mitchell, CodeSourcery, LLC.
   6    <mark@codesourcery.com>
   7
   8 This file is part of BFD, the Binary File Descriptor library.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 /* This file supports the 64-bit MIPS ELF ABI.
  25
  26    The MIPS 64-bit ELF ABI uses an unusual reloc format.  This file
  27    overrides the usual ELF reloc handling, and handles reading and
  28    writing the relocations here.  */
  29
  30 /* TODO: Many things are unsupported, even if there is some code for it
  31  .       (which was mostly stolen from elf32-mips.c and slightly adapted).
  32  .
  33  .   - Relocation handling for REL relocs is wrong in many cases and
  34  .     generally untested.
  35  .   - Relocation handling for RELA relocs related to GOT support are
  36  .     also likely to be wrong.
  37  .   - Support for MIPS16 is only partially implemented.
  38  .   - Embedded PIC  is only partially implemented (is it needed?).
  39  .   - Combined relocs with RSS_* entries are unsupported.
  40  .   - The whole GOT handling for NewABI is missing, some parts of
  41  .     the OldABI version is still lying around and shold be removed.
  42  */
  43
  44 #include "bfd.h"
  45 #include "sysdep.h"
  46 #include "libbfd.h"
  47 #include "aout/ar.h"
  48 #include "bfdlink.h"
  49 #include "genlink.h"
  50 #include "elf-bfd.h"
  51 #include "elf/mips.h"
  52
  53 /* Get the ECOFF swapping routines.  The 64-bit ABI is not supposed to
  54    use ECOFF.  However, we support it anyhow for an easier changeover.  */
  55 #include "coff/sym.h"
  56 #include "coff/symconst.h"
  57 #include "coff/internal.h"
  58 #include "coff/ecoff.h"
  59 /* The 64 bit versions of the mdebug data structures are in alpha.h.  */
  60 #include "coff/alpha.h"
  61 #define ECOFF_SIGNED_64
  62 #include "ecoffswap.h"
  63
  64 struct mips_elf64_link_hash_entry;
  65
  66 static void mips_elf64_swap_reloc_in
  67   PARAMS ((bfd *, const Elf64_Mips_External_Rel *,
  68            Elf64_Mips_Internal_Rel *));
  69 static void mips_elf64_swap_reloca_in
  70   PARAMS ((bfd *, const Elf64_Mips_External_Rela *,
  71            Elf64_Mips_Internal_Rela *));
  72 static void mips_elf64_swap_reloc_out
  73   PARAMS ((bfd *, const Elf64_Mips_Internal_Rel *,
  74            Elf64_Mips_External_Rel *));
  75 static void mips_elf64_swap_reloca_out
  76   PARAMS ((bfd *, const Elf64_Mips_Internal_Rela *,
  77            Elf64_Mips_External_Rela *));
  78 static void mips_elf64_be_swap_reloc_in
  79   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rel *));
  80 static void mips_elf64_be_swap_reloc_out
  81   PARAMS ((bfd *, const Elf_Internal_Rel *, bfd_byte *));
  82 static void mips_elf64_be_swap_reloca_in
  83   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
  84 static void mips_elf64_be_swap_reloca_out
  85   PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
  86 static bfd_vma mips_elf64_high PARAMS ((bfd_vma));
  87 static bfd_vma mips_elf64_higher PARAMS ((bfd_vma));
  88 static bfd_vma mips_elf64_highest PARAMS ((bfd_vma));
  89 static reloc_howto_type *mips_elf64_reloc_type_lookup
  90   PARAMS ((bfd *, bfd_reloc_code_real_type));
  91 static void mips_elf64_info_to_howto_rel
  92   PARAMS ((bfd *, arelent *, Elf64_Internal_Rel *));
  93 static void mips_elf64_info_to_howto_rela
  94   PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
  95 static long mips_elf64_get_reloc_upper_bound PARAMS ((bfd *, asection *));
  96 static boolean mips_elf64_slurp_one_reloc_table
  97   PARAMS ((bfd *, asection *, asymbol **, const Elf_Internal_Shdr *));
  98 static boolean mips_elf64_slurp_reloc_table
  99   PARAMS ((bfd *, asection *, asymbol **, boolean));
 100 static void mips_elf64_write_relocs PARAMS ((bfd *, asection *, PTR));
 101 static void mips_elf64_write_rel
 102   PARAMS((bfd *, asection *, Elf_Internal_Shdr *, int *, PTR));
 103 static void mips_elf64_write_rela
 104   PARAMS((bfd *, asection *, Elf_Internal_Shdr *, int *, PTR));
 105 static struct bfd_hash_entry *mips_elf64_link_hash_newfunc
 106   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 107 static bfd_reloc_status_type mips_elf64_hi16_reloc
 108   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 109 static bfd_reloc_status_type mips_elf64_higher_reloc
 110   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 111 static bfd_reloc_status_type mips_elf64_highest_reloc
 112   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 113 static bfd_reloc_status_type mips_elf64_gprel16_reloc
 114   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 115 static bfd_reloc_status_type mips_elf64_gprel16_reloca
 116   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 117 static bfd_reloc_status_type mips_elf64_literal_reloc
 118   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 119 static bfd_reloc_status_type mips_elf64_gprel32_reloc
 120   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 121 static bfd_reloc_status_type mips_elf64_shift6_reloc
 122   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 123 static bfd_reloc_status_type mips_elf64_got16_reloc
 124   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 125 static boolean mips_elf64_assign_gp PARAMS ((bfd *, bfd_vma *));
 126 static bfd_reloc_status_type mips_elf64_final_gp
 127   PARAMS ((bfd *, asymbol *, boolean, char **, bfd_vma *));
 128 static bfd_reloc_status_type gprel16_with_gp
 129   PARAMS ((bfd *, asymbol *, arelent *, asection *, boolean, PTR, bfd_vma));
 130 static int mips_elf64_additional_program_headers PARAMS ((bfd *));
 131 static struct bfd_link_hash_table *mips_elf64_link_hash_table_create
 132   PARAMS((bfd *));
 133 static bfd_vma mips_elf64_got_offset_from_index
 134   PARAMS ((bfd *, bfd *, bfd_vma));
 135 static struct mips_elf64_got_info *_mips_elf64_got_info
 136   PARAMS ((bfd *, asection **));
 137 static bfd_vma mips_elf64_sign_extend PARAMS ((bfd_vma, int));
 138 static boolean mips_elf64_overflow_p PARAMS ((bfd_vma, int));
 139 static bfd_vma mips_elf64_global_got_index
 140   PARAMS ((bfd *, struct elf_link_hash_entry *));
 141 static boolean mips_elf64_sort_hash_table_f
 142   PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
 143 static boolean mips_elf64_sort_hash_table
 144   PARAMS ((struct bfd_link_info *, unsigned long));
 145 static void mips_elf64_swap_msym_out
 146   PARAMS ((bfd *, const Elf32_Internal_Msym *, Elf32_External_Msym *));
 147 static bfd_vma mips_elf64_create_local_got_entry
 148   PARAMS ((bfd *abfd, struct mips_elf64_got_info *, asection *,
 149            bfd_vma value));
 150 static bfd_vma mips_elf64_local_got_index
 151   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma));
 152 static bfd_vma mips_elf64_got_page
 153   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *));
 154 static bfd_vma mips_elf64_got16_entry
 155   PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, boolean));
 156 static boolean mips_elf64_local_relocation_p
 157   PARAMS ((bfd *, const Elf_Internal_Rela *, asection **, boolean));
 158 static const Elf_Internal_Rela *mips_elf64_next_relocation
 159   PARAMS ((unsigned int, const Elf_Internal_Rela *,
 160            const Elf_Internal_Rela *));
 161 static boolean mips_elf64_create_dynamic_relocation
 162   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
 163            struct mips_elf64_link_hash_entry *, asection *, bfd_vma,
 164            bfd_vma *, asection *));
 165 static bfd_reloc_status_type mips_elf64_calculate_relocation
 166   PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
 167            const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
 168            Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
 169            boolean *));
 170 static bfd_vma mips_elf64_obtain_contents
 171   PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
 172 static boolean mips_elf64_perform_relocation
 173   PARAMS ((struct bfd_link_info *, reloc_howto_type *,
 174            const Elf_Internal_Rela *, bfd_vma,
 175            bfd *, asection *, bfd_byte *, boolean));
 176 static boolean mips_elf64_relocate_section
 177   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 178            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
 179 boolean mips_elf64_create_dynamic_sections
 180   PARAMS ((bfd *, struct bfd_link_info *));
 181 boolean mips_elf64_adjust_dynamic_symbol
 182   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *h));
 183 boolean mips_elf64_always_size_sections
 184   PARAMS ((bfd *, struct bfd_link_info *));
 185 static boolean mips_elf64_check_mips16_stubs
 186   PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
 187 boolean mips_elf64_size_dynamic_sections
 188   PARAMS ((bfd *, struct bfd_link_info *));
 189 boolean mips_elf64_finish_dynamic_symbol
 190   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
 191            Elf_Internal_Sym *));
 192 boolean mips_elf64_finish_dynamic_sections
 193   PARAMS ((bfd *, struct bfd_link_info *info));
 194 asection *mips_elf64_gc_mark_hook
 195   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
 196            struct elf_link_hash_entry *, Elf_Internal_Sym *));
 197 boolean mips_elf64_gc_sweep_hook
 198   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 199            const Elf_Internal_Rela *));
 200 static boolean mips_elf64_create_got_section
 201   PARAMS ((bfd *, struct bfd_link_info *));
 202 static boolean mips_elf64_record_global_got_symbol
 203   PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *,
 204            struct mips_elf64_got_info *));
 205 static asection *mips_elf64_create_msym_section PARAMS((bfd *));
 206 static void mips_elf64_allocate_dynamic_relocations
 207   PARAMS ((bfd *, unsigned int));
 208 static boolean mips_elf64_stub_section_p PARAMS ((bfd *, asection *));
 209 boolean mips_elf64_check_relocs
 210   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 211            const Elf_Internal_Rela *));
 212 static boolean mips_elf64_output_extsym
 213         PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
 214 static void mips_elf64_swap_gptab_in
 215   PARAMS ((bfd *, const Elf32_External_gptab *, Elf32_gptab *));
 216 static void mips_elf64_swap_gptab_out
 217   PARAMS ((bfd *, const Elf32_gptab *, Elf32_External_gptab *));
 218 static int gptab_compare PARAMS ((const PTR, const PTR));
 219 boolean mips_elf64_final_link PARAMS ((bfd *, struct bfd_link_info *));
 220
 221 extern const bfd_target bfd_elf64_bigmips_vec;
 222 extern const bfd_target bfd_elf64_littlemips_vec;
 223
 224 static bfd_vma prev_reloc_addend = 0;
 225 static bfd_size_type prev_reloc_address = 0;
 226
 227 /* Whether we are trying to be compatible with IRIX6 (or little endianers
 228    which are otherwise IRIX-ABI compliant).  */
 229 #define SGI_COMPAT(abfd) \
 230   ((abfd->xvec == &bfd_elf64_bigmips_vec) \
 231    || (abfd->xvec == &bfd_elf64_littlemips_vec) ? true : false)
 232
 233 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 234    from smaller values.  Start with zero, widen, *then* decrement.  */
 235 #define MINUS_ONE       (((bfd_vma)0) - 1)
 236
 237 /* The number of local .got entries we reserve.  */
 238 #define MIPS_RESERVED_GOTNO (2)
 239
 240 /* Instructions which appear in a stub.  */
 241 #define ELF_MIPS_GP_OFFSET(abfd) 0x7ff0
 242 #define STUB_LW    0xdf998010   /* ld t9,0x8010(gp) */
 243 #define STUB_MOVE  0x03e07825   /* move t7,ra */
 244 #define STUB_JALR  0x0320f809   /* jal t9 */
 245 #define STUB_LI16  0x34180000   /* ori t8,zero,0 */
 246 #define MIPS_FUNCTION_STUB_SIZE (16)
 247
 248 /* The relocation table used for SHT_REL sections.  */
 249
 250 #define UNUSED_RELOC(num) { num, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 251
 252 static reloc_howto_type mips_elf64_howto_table_rel[] =
 253 {
 254   /* No relocation.  */
 255   HOWTO (R_MIPS_NONE,           /* type */
 256          0,                     /* rightshift */
 257          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 258          0,                     /* bitsize */
 259          false,                 /* pc_relative */
 260          0,                     /* bitpos */
 261          complain_overflow_dont, /* complain_on_overflow */
 262          bfd_elf_generic_reloc, /* special_function */
 263          "R_MIPS_NONE",         /* name */
 264          false,                 /* partial_inplace */
 265          0,                     /* src_mask */
 266          0,                     /* dst_mask */
 267          false),                /* pcrel_offset */
 268
 269   /* 16 bit relocation.  */
 270   HOWTO (R_MIPS_16,             /* type */
 271          0,                     /* rightshift */
 272          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 273          16,                    /* bitsize */
 274          false,                 /* pc_relative */
 275          0,                     /* bitpos */
 276          complain_overflow_signed, /* complain_on_overflow */
 277          bfd_elf_generic_reloc, /* special_function */
 278          "R_MIPS_16",           /* name */
 279          true,                  /* partial_inplace */
 280          0x0000ffff,            /* src_mask */
 281          0x0000ffff,            /* dst_mask */
 282          false),                /* pcrel_offset */
 283
 284   /* 32 bit relocation.  */
 285   HOWTO (R_MIPS_32,             /* type */
 286          0,                     /* rightshift */
 287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 288          32,                    /* bitsize */
 289          false,                 /* pc_relative */
 290          0,                     /* bitpos */
 291          complain_overflow_dont, /* complain_on_overflow */
 292          bfd_elf_generic_reloc, /* special_function */
 293          "R_MIPS_32",           /* name */
 294          true,                  /* partial_inplace */
 295          0xffffffff,            /* src_mask */
 296          0xffffffff,            /* dst_mask */
 297          false),                /* pcrel_offset */
 298
 299   /* 32 bit symbol relative relocation.  */
 300   HOWTO (R_MIPS_REL32,          /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          32,                    /* bitsize */
 304          false,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_dont, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_MIPS_REL32",        /* name */
 309          true,                  /* partial_inplace */
 310          0xffffffff,            /* src_mask */
 311          0xffffffff,            /* dst_mask */
 312          false),                /* pcrel_offset */
 313
 314   /* 26 bit jump address.  */
 315   HOWTO (R_MIPS_26,             /* type */
 316          2,                     /* rightshift */
 317          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          26,                    /* bitsize */
 319          false,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_dont, /* complain_on_overflow */
 322                                 /* This needs complex overflow
 323                                    detection, because the upper 36
 324                                    bits must match the PC + 4.  */
 325          bfd_elf_generic_reloc, /* special_function */
 326          "R_MIPS_26",           /* name */
 327          true,                  /* partial_inplace */
 328          0x03ffffff,            /* src_mask */
 329          0x03ffffff,            /* dst_mask */
 330          false),                /* pcrel_offset */
 331
 332   /* High 16 bits of symbol value.  */
 333   HOWTO (R_MIPS_HI16,           /* type */
 334          0,                     /* rightshift */
 335          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 336          16,                    /* bitsize */
 337          false,                 /* pc_relative */
 338          0,                     /* bitpos */
 339          complain_overflow_dont, /* complain_on_overflow */
 340          bfd_elf_generic_reloc, /* special_function */
 341          "R_MIPS_HI16",         /* name */
 342          true,                  /* partial_inplace */
 343          0x0000ffff,            /* src_mask */
 344          0x0000ffff,            /* dst_mask */
 345          false),                /* pcrel_offset */
 346
 347   /* Low 16 bits of symbol value.  */
 348   HOWTO (R_MIPS_LO16,           /* type */
 349          0,                     /* rightshift */
 350          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 351          16,                    /* bitsize */
 352          false,                 /* pc_relative */
 353          0,                     /* bitpos */
 354          complain_overflow_dont, /* complain_on_overflow */
 355          bfd_elf_generic_reloc, /* special_function */
 356          "R_MIPS_LO16",         /* name */
 357          true,                  /* partial_inplace */
 358          0x0000ffff,            /* src_mask */
 359          0x0000ffff,            /* dst_mask */
 360          false),                /* pcrel_offset */
 361
 362   /* GP relative reference.  */
 363   HOWTO (R_MIPS_GPREL16,        /* type */
 364          0,                     /* rightshift */
 365          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 366          16,                    /* bitsize */
 367          false,                 /* pc_relative */
 368          0,                     /* bitpos */
 369          complain_overflow_signed, /* complain_on_overflow */
 370          mips_elf64_gprel16_reloc, /* special_function */
 371          "R_MIPS_GPREL16",      /* name */
 372          true,                  /* partial_inplace */
 373          0x0000ffff,            /* src_mask */
 374          0x0000ffff,            /* dst_mask */
 375          false),                /* pcrel_offset */
 376
 377   /* Reference to literal section.  */
 378   HOWTO (R_MIPS_LITERAL,        /* type */
 379          0,                     /* rightshift */
 380          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 381          16,                    /* bitsize */
 382          false,                 /* pc_relative */
 383          0,                     /* bitpos */
 384          complain_overflow_signed, /* complain_on_overflow */
 385          mips_elf64_literal_reloc, /* special_function */
 386          "R_MIPS_LITERAL",      /* name */
 387          true,                  /* partial_inplace */
 388          0x0000ffff,            /* src_mask */
 389          0x0000ffff,            /* dst_mask */
 390          false),                /* pcrel_offset */
 391
 392   /* Reference to global offset table.  */
 393   HOWTO (R_MIPS_GOT16,          /* type */
 394          0,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          16,                    /* bitsize */
 397          false,                 /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_signed, /* complain_on_overflow */
 400          mips_elf64_got16_reloc, /* special_function */
 401          "R_MIPS_GOT16",        /* name */
 402          true,                  /* partial_inplace */
 403          0x0000ffff,            /* src_mask */
 404          0x0000ffff,            /* dst_mask */
 405          false),                /* pcrel_offset */
 406
 407   /* 16 bit PC relative reference.  */
 408   HOWTO (R_MIPS_PC16,           /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          true,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* special_function */
 416          "R_MIPS_PC16",         /* name */
 417          true,                  /* partial_inplace */
 418          0x0000ffff,            /* src_mask */
 419          0x0000ffff,            /* dst_mask */
 420          true),                 /* pcrel_offset */
 421
 422   /* 16 bit call through global offset table.  */
 423   /* FIXME: This is not handled correctly.  */
 424   HOWTO (R_MIPS_CALL16,         /* type */
 425          0,                     /* rightshift */
 426          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 427          16,                    /* bitsize */
 428          false,                 /* pc_relative */
 429          0,                     /* bitpos */
 430          complain_overflow_signed, /* complain_on_overflow */
 431          bfd_elf_generic_reloc, /* special_function */
 432          "R_MIPS_CALL16",       /* name */
 433          true,                  /* partial_inplace */
 434          0x0000ffff,            /* src_mask */
 435          0x0000ffff,            /* dst_mask */
 436          false),                /* pcrel_offset */
 437
 438   /* 32 bit GP relative reference.  */
 439   HOWTO (R_MIPS_GPREL32,        /* type */
 440          0,                     /* rightshift */
 441          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 442          32,                    /* bitsize */
 443          false,                 /* pc_relative */
 444          0,                     /* bitpos */
 445          complain_overflow_dont, /* complain_on_overflow */
 446          mips_elf64_gprel32_reloc, /* special_function */
 447          "R_MIPS_GPREL32",      /* name */
 448          true,                  /* partial_inplace */
 449          0xffffffff,            /* src_mask */
 450          0xffffffff,            /* dst_mask */
 451          false),                /* pcrel_offset */
 452
 453   UNUSED_RELOC (13),
 454   UNUSED_RELOC (14),
 455   UNUSED_RELOC (15),
 456
 457   /* A 5 bit shift field.  */
 458   HOWTO (R_MIPS_SHIFT5,         /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          5,                     /* bitsize */
 462          false,                 /* pc_relative */
 463          6,                     /* bitpos */
 464          complain_overflow_bitfield, /* complain_on_overflow */
 465          bfd_elf_generic_reloc, /* special_function */
 466          "R_MIPS_SHIFT5",       /* name */
 467          true,                  /* partial_inplace */
 468          0x000007c0,            /* src_mask */
 469          0x000007c0,            /* dst_mask */
 470          false),                /* pcrel_offset */
 471
 472   /* A 6 bit shift field.  */
 473   HOWTO (R_MIPS_SHIFT6,         /* type */
 474          0,                     /* rightshift */
 475          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          6,                     /* bitsize */
 477          false,                 /* pc_relative */
 478          6,                     /* bitpos */
 479          complain_overflow_bitfield, /* complain_on_overflow */
 480          mips_elf64_shift6_reloc, /* special_function */
 481          "R_MIPS_SHIFT6",       /* name */
 482          true,                  /* partial_inplace */
 483          0x000007c4,            /* src_mask */
 484          0x000007c4,            /* dst_mask */
 485          false),                /* pcrel_offset */
 486
 487   /* 64 bit relocation.  */
 488   HOWTO (R_MIPS_64,             /* type */
 489          0,                     /* rightshift */
 490          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 491          64,                    /* bitsize */
 492          false,                 /* pc_relative */
 493          0,                     /* bitpos */
 494          complain_overflow_dont, /* complain_on_overflow */
 495          bfd_elf_generic_reloc, /* special_function */
 496          "R_MIPS_64",           /* name */
 497          true,                  /* partial_inplace */
 498          MINUS_ONE,             /* src_mask */
 499          MINUS_ONE,             /* dst_mask */
 500          false),                /* pcrel_offset */
 501
 502   /* Displacement in the global offset table.  */
 503   /* FIXME: Not handled correctly.  */
 504   HOWTO (R_MIPS_GOT_DISP,       /* type */
 505          0,                     /* rightshift */
 506          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 507          16,                    /* bitsize */
 508          false,                 /* pc_relative */
 509          0,                     /* bitpos */
 510          complain_overflow_signed, /* complain_on_overflow */
 511          bfd_elf_generic_reloc, /* special_function */
 512          "R_MIPS_GOT_DISP",     /* name */
 513          true,                  /* partial_inplace */
 514          0x0000ffff,            /* src_mask */
 515          0x0000ffff,            /* dst_mask */
 516          false),                /* pcrel_offset */
 517
 518   /* Displacement to page pointer in the global offset table.  */
 519   /* FIXME: Not handled correctly.  */
 520   HOWTO (R_MIPS_GOT_PAGE,       /* type */
 521          0,                     /* rightshift */
 522          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 523          16,                    /* bitsize */
 524          false,                 /* pc_relative */
 525          0,                     /* bitpos */
 526          complain_overflow_signed, /* complain_on_overflow */
 527          bfd_elf_generic_reloc, /* special_function */
 528          "R_MIPS_GOT_PAGE",     /* name */
 529          true,                  /* partial_inplace */
 530          0x0000ffff,            /* src_mask */
 531          0x0000ffff,            /* dst_mask */
 532          false),                /* pcrel_offset */
 533
 534   /* Offset from page pointer in the global offset table.  */
 535   /* FIXME: Not handled correctly.  */
 536   HOWTO (R_MIPS_GOT_OFST,       /* type */
 537          0,                     /* rightshift */
 538          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 539          16,                    /* bitsize */
 540          false,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_signed, /* complain_on_overflow */
 543          bfd_elf_generic_reloc, /* special_function */
 544          "R_MIPS_GOT_OFST",     /* name */
 545          true,                  /* partial_inplace */
 546          0x0000ffff,            /* src_mask */
 547          0x0000ffff,            /* dst_mask */
 548          false),                /* pcrel_offset */
 549
 550   /* High 16 bits of displacement in global offset table.  */
 551   /* FIXME: Not handled correctly.  */
 552   HOWTO (R_MIPS_GOT_HI16,       /* type */
 553          0,                     /* rightshift */
 554          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 555          16,                    /* bitsize */
 556          false,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          bfd_elf_generic_reloc, /* special_function */
 560          "R_MIPS_GOT_HI16",     /* name */
 561          true,                  /* partial_inplace */
 562          0x0000ffff,            /* src_mask */
 563          0x0000ffff,            /* dst_mask */
 564          false),                /* pcrel_offset */
 565
 566   /* Low 16 bits of displacement in global offset table.  */
 567   /* FIXME: Not handled correctly.  */
 568   HOWTO (R_MIPS_GOT_LO16,       /* type */
 569          0,                     /* rightshift */
 570          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          16,                    /* bitsize */
 572          false,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          bfd_elf_generic_reloc, /* special_function */
 576          "R_MIPS_GOT_LO16",     /* name */
 577          true,                  /* partial_inplace */
 578          0x0000ffff,            /* src_mask */
 579          0x0000ffff,            /* dst_mask */
 580          false),                /* pcrel_offset */
 581
 582   /* 64 bit substraction.  */
 583   /* FIXME: Not handled correctly.  */
 584   HOWTO (R_MIPS_SUB,            /* type */
 585          0,                     /* rightshift */
 586          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 587          64,                    /* bitsize */
 588          false,                 /* pc_relative */
 589          0,                     /* bitpos */
 590          complain_overflow_dont, /* complain_on_overflow */
 591          bfd_elf_generic_reloc, /* special_function */
 592          "R_MIPS_SUB",          /* name */
 593          true,                  /* partial_inplace */
 594          MINUS_ONE,             /* src_mask */
 595          MINUS_ONE,             /* dst_mask */
 596          false),                /* pcrel_offset */
 597
 598   /* Insert the addend as an instruction.  */
 599   /* FIXME: Not handled correctly.  */
 600   HOWTO (R_MIPS_INSERT_A,       /* type */
 601          0,                     /* rightshift */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 603          32,                    /* bitsize */
 604          false,                 /* pc_relative */
 605          0,                     /* bitpos */
 606          complain_overflow_dont, /* complain_on_overflow */
 607          bfd_elf_generic_reloc, /* special_function */
 608          "R_MIPS_INSERT_A",     /* name */
 609          true,                  /* partial_inplace */
 610          0xffffffff,            /* src_mask */
 611          0xffffffff,            /* dst_mask */
 612          false),                /* pcrel_offset */
 613
 614   /* Insert the addend as an instruction, and change all relocations
 615      to refer to the old instruction at the address.  */
 616   /* FIXME: Not handled correctly.  */
 617   HOWTO (R_MIPS_INSERT_B,       /* type */
 618          0,                     /* rightshift */
 619          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 620          32,                    /* bitsize */
 621          false,                 /* pc_relative */
 622          0,                     /* bitpos */
 623          complain_overflow_dont, /* complain_on_overflow */
 624          bfd_elf_generic_reloc, /* special_function */
 625          "R_MIPS_INSERT_B",     /* name */
 626          true,                  /* partial_inplace */
 627          0xffffffff,            /* src_mask */
 628          0xffffffff,            /* dst_mask */
 629          false),                /* pcrel_offset */
 630
 631   /* Delete a 32 bit instruction.  */
 632   /* FIXME: Not handled correctly.  */
 633   HOWTO (R_MIPS_DELETE,         /* type */
 634          0,                     /* rightshift */
 635          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 636          32,                    /* bitsize */
 637          false,                 /* pc_relative */
 638          0,                     /* bitpos */
 639          complain_overflow_dont, /* complain_on_overflow */
 640          bfd_elf_generic_reloc, /* special_function */
 641          "R_MIPS_DELETE",       /* name */
 642          true,                  /* partial_inplace */
 643          0xffffffff,            /* src_mask */
 644          0xffffffff,            /* dst_mask */
 645          false),                /* pcrel_offset */
 646
 647   /* Get the higher value of a 64 bit addend.  */
 648   HOWTO (R_MIPS_HIGHER,         /* type */
 649          0,                     /* rightshift */
 650          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 651          16,                    /* bitsize */
 652          false,                 /* pc_relative */
 653          0,                     /* bitpos */
 654          complain_overflow_dont, /* complain_on_overflow */
 655          mips_elf64_higher_reloc, /* special_function */
 656          "R_MIPS_HIGHER",       /* name */
 657          true,                  /* partial_inplace */
 658          0x0000ffff,            /* src_mask */
 659          0x0000ffff,            /* dst_mask */
 660          false),                /* pcrel_offset */
 661
 662   /* Get the highest value of a 64 bit addend.  */
 663   HOWTO (R_MIPS_HIGHEST,        /* type */
 664          0,                     /* rightshift */
 665          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 666          16,                    /* bitsize */
 667          false,                 /* pc_relative */
 668          0,                     /* bitpos */
 669          complain_overflow_dont, /* complain_on_overflow */
 670          mips_elf64_highest_reloc, /* special_function */
 671          "R_MIPS_HIGHEST",      /* name */
 672          true,                  /* partial_inplace */
 673          0x0000ffff,            /* src_mask */
 674          0x0000ffff,            /* dst_mask */
 675          false),                /* pcrel_offset */
 676
 677   /* High 16 bits of displacement in global offset table.  */
 678   /* FIXME: Not handled correctly.  */
 679   HOWTO (R_MIPS_CALL_HI16,      /* type */
 680          0,                     /* rightshift */
 681          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 682          16,                    /* bitsize */
 683          false,                 /* pc_relative */
 684          0,                     /* bitpos */
 685          complain_overflow_dont, /* complain_on_overflow */
 686          bfd_elf_generic_reloc, /* special_function */
 687          "R_MIPS_CALL_HI16",    /* name */
 688          true,                  /* partial_inplace */
 689          0x0000ffff,            /* src_mask */
 690          0x0000ffff,            /* dst_mask */
 691          false),                /* pcrel_offset */
 692
 693   /* Low 16 bits of displacement in global offset table.  */
 694   /* FIXME: Not handled correctly.  */
 695   HOWTO (R_MIPS_CALL_LO16,      /* type */
 696          0,                     /* rightshift */
 697          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 698          16,                    /* bitsize */
 699          false,                 /* pc_relative */
 700          0,                     /* bitpos */
 701          complain_overflow_dont, /* complain_on_overflow */
 702          bfd_elf_generic_reloc, /* special_function */
 703          "R_MIPS_CALL_LO16",    /* name */
 704          true,                  /* partial_inplace */
 705          0x0000ffff,            /* src_mask */
 706          0x0000ffff,            /* dst_mask */
 707          false),                /* pcrel_offset */
 708
 709   /* Section displacement, used by an associated event location section.  */
 710   /* FIXME: Not handled correctly.  */
 711   HOWTO (R_MIPS_SCN_DISP,       /* type */
 712          0,                     /* rightshift */
 713          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 714          32,                    /* bitsize */
 715          false,                 /* pc_relative */
 716          0,                     /* bitpos */
 717          complain_overflow_dont, /* complain_on_overflow */
 718          bfd_elf_generic_reloc, /* special_function */
 719          "R_MIPS_SCN_DISP",     /* name */
 720          true,                  /* partial_inplace */
 721          0xffffffff,            /* src_mask */
 722          0xffffffff,            /* dst_mask */
 723          false),                /* pcrel_offset */
 724
 725   HOWTO (R_MIPS_REL16,          /* type */
 726          0,                     /* rightshift */
 727          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 728          16,                    /* bitsize */
 729          false,                 /* pc_relative */
 730          0,                     /* bitpos */
 731          complain_overflow_signed, /* complain_on_overflow */
 732          bfd_elf_generic_reloc, /* special_function */
 733          "R_MIPS_REL16",        /* name */
 734          true,                  /* partial_inplace */
 735          0xffff,                /* src_mask */
 736          0xffff,                /* dst_mask */
 737          false),                /* pcrel_offset */
 738
 739   /* These two are obsolete.  */
 740   EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
 741   EMPTY_HOWTO (R_MIPS_PJUMP),
 742
 743   /* Similiar to R_MIPS_REL32, but used for relocations in a GOT section.
 744      It must be used for multigot GOT's (and only there).  */
 745   HOWTO (R_MIPS_RELGOT,         /* type */
 746          0,                     /* rightshift */
 747          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          32,                    /* bitsize */
 749          false,                 /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_dont, /* complain_on_overflow */
 752          bfd_elf_generic_reloc, /* special_function */
 753          "R_MIPS_RELGOT",       /* name */
 754          true,                  /* partial_inplace */
 755          0xffffffff,            /* src_mask */
 756          0xffffffff,            /* dst_mask */
 757          false),                /* pcrel_offset */
 758
 759   /* Protected jump conversion.  This is an optimization hint.  No
 760      relocation is required for correctness.  */
 761   HOWTO (R_MIPS_JALR,           /* type */
 762          0,                     /* rightshift */
 763          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          32,                    /* bitsize */
 765          false,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          bfd_elf_generic_reloc, /* special_function */
 769          "R_MIPS_JALR",         /* name */
 770          false,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0x00000000,            /* dst_mask */
 773          false),                /* pcrel_offset */
 774 };
 775
 776 /* The relocation table used for SHT_RELA sections.  */
 777
 778 static reloc_howto_type mips_elf64_howto_table_rela[] =
 779 {
 780   /* No relocation.  */
 781   HOWTO (R_MIPS_NONE,           /* type */
 782          0,                     /* rightshift */
 783          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          0,                     /* bitsize */
 785          false,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_dont, /* complain_on_overflow */
 788          bfd_elf_generic_reloc, /* special_function */
 789          "R_MIPS_NONE",         /* name */
 790          false,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0,                     /* dst_mask */
 793          false),                /* pcrel_offset */
 794
 795   /* 16 bit relocation.  */
 796   HOWTO (R_MIPS_16,             /* type */
 797          0,                     /* rightshift */
 798          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          false,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          bfd_elf_generic_reloc, /* special_function */
 804          "R_MIPS_16",           /* name */
 805          false,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0x0000ffff,            /* dst_mask */
 808          false),                /* pcrel_offset */
 809
 810   /* 32 bit relocation.  */
 811   HOWTO (R_MIPS_32,             /* type */
 812          0,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          32,                    /* bitsize */
 815          false,                 /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_MIPS_32",           /* name */
 820          false,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xffffffff,            /* dst_mask */
 823          false),                /* pcrel_offset */
 824
 825   /* 32 bit symbol relative relocation.  */
 826   HOWTO (R_MIPS_REL32,          /* type */
 827          0,                     /* rightshift */
 828          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 829          32,                    /* bitsize */
 830          false,                 /* pc_relative */
 831          0,                     /* bitpos */
 832          complain_overflow_dont, /* complain_on_overflow */
 833          bfd_elf_generic_reloc, /* special_function */
 834          "R_MIPS_REL32",        /* name */
 835          false,                 /* partial_inplace */
 836          0,                     /* src_mask */
 837          0xffffffff,            /* dst_mask */
 838          false),                /* pcrel_offset */
 839
 840   /* 26 bit jump address.  */
 841   HOWTO (R_MIPS_26,             /* type */
 842          2,                     /* rightshift */
 843          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 844          26,                    /* bitsize */
 845          false,                 /* pc_relative */
 846          0,                     /* bitpos */
 847          complain_overflow_dont, /* complain_on_overflow */
 848                                 /* This needs complex overflow
 849                                    detection, because the upper 36
 850                                    bits must match the PC + 4.  */
 851          bfd_elf_generic_reloc, /* special_function */
 852          "R_MIPS_26",           /* name */
 853          false,                 /* partial_inplace */
 854          0,                     /* src_mask */
 855          0x03ffffff,            /* dst_mask */
 856          false),                /* pcrel_offset */
 857
 858   /* R_MIPS_HI16 and R_MIPS_LO16 are unsupported for 64 bit REL.  */
 859   /* High 16 bits of symbol value.  */
 860   HOWTO (R_MIPS_HI16,           /* type */
 861          0,                     /* rightshift */
 862          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 863          16,                    /* bitsize */
 864          false,                 /* pc_relative */
 865          0,                     /* bitpos */
 866          complain_overflow_dont, /* complain_on_overflow */
 867          bfd_elf_generic_reloc, /* special_function */
 868          "R_MIPS_HI16",         /* name */
 869          false,                 /* partial_inplace */
 870          0,                     /* src_mask */
 871          0x0000ffff,            /* dst_mask */
 872          false),                /* pcrel_offset */
 873
 874   /* Low 16 bits of symbol value.  */
 875   HOWTO (R_MIPS_LO16,           /* type */
 876          0,                     /* rightshift */
 877          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 878          16,                    /* bitsize */
 879          false,                 /* pc_relative */
 880          0,                     /* bitpos */
 881          complain_overflow_dont, /* complain_on_overflow */
 882          bfd_elf_generic_reloc, /* special_function */
 883          "R_MIPS_LO16",         /* name */
 884          false,                 /* partial_inplace */
 885          0,                     /* src_mask */
 886          0x0000ffff,            /* dst_mask */
 887          false),                /* pcrel_offset */
 888
 889   /* GP relative reference.  */
 890   HOWTO (R_MIPS_GPREL16,        /* type */
 891          0,                     /* rightshift */
 892          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          false,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_signed, /* complain_on_overflow */
 897          mips_elf64_gprel16_reloca, /* special_function */
 898          "R_MIPS_GPREL16",      /* name */
 899          false,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0x0000ffff,            /* dst_mask */
 902          false),                /* pcrel_offset */
 903
 904   /* Reference to literal section.  */
 905   HOWTO (R_MIPS_LITERAL,        /* type */
 906          0,                     /* rightshift */
 907          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 908          16,                    /* bitsize */
 909          false,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_signed, /* complain_on_overflow */
 912          mips_elf64_literal_reloc, /* special_function */
 913          "R_MIPS_LITERAL",      /* name */
 914          false,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          0x0000ffff,            /* dst_mask */
 917          false),                /* pcrel_offset */
 918
 919   /* Reference to global offset table.  */
 920   /* FIXME: This is not handled correctly.  */
 921   HOWTO (R_MIPS_GOT16,          /* type */
 922          0,                     /* rightshift */
 923          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 924          16,                    /* bitsize */
 925          false,                 /* pc_relative */
 926          0,                     /* bitpos */
 927          complain_overflow_signed, /* complain_on_overflow */
 928          bfd_elf_generic_reloc, /* special_function */
 929          "R_MIPS_GOT16",        /* name */
 930          false,                 /* partial_inplace */
 931          0,                     /* src_mask */
 932          0x0000ffff,            /* dst_mask */
 933          false),                /* pcrel_offset */
 934
 935   /* 16 bit PC relative reference.  */
 936   HOWTO (R_MIPS_PC16,           /* type */
 937          0,                     /* rightshift */
 938          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 939          16,                    /* bitsize */
 940          true,                  /* pc_relative */
 941          0,                     /* bitpos */
 942          complain_overflow_signed, /* complain_on_overflow */
 943          bfd_elf_generic_reloc, /* special_function */
 944          "R_MIPS_PC16",         /* name */
 945          false,                 /* partial_inplace */
 946          0,                     /* src_mask */
 947          0x0000ffff,            /* dst_mask */
 948          true),                 /* pcrel_offset */
 949
 950   /* 16 bit call through global offset table.  */
 951   /* FIXME: This is not handled correctly.  */
 952   HOWTO (R_MIPS_CALL16,         /* type */
 953          0,                     /* rightshift */
 954          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 955          16,                    /* bitsize */
 956          false,                 /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_signed, /* complain_on_overflow */
 959          bfd_elf_generic_reloc, /* special_function */
 960          "R_MIPS_CALL16",       /* name */
 961          false,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          0x0000ffff,            /* dst_mask */
 964          false),                /* pcrel_offset */
 965
 966   /* 32 bit GP relative reference.  */
 967   HOWTO (R_MIPS_GPREL32,        /* type */
 968          0,                     /* rightshift */
 969          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 970          32,                    /* bitsize */
 971          false,                 /* pc_relative */
 972          0,                     /* bitpos */
 973          complain_overflow_dont, /* complain_on_overflow */
 974          mips_elf64_gprel32_reloc, /* special_function */
 975          "R_MIPS_GPREL32",      /* name */
 976          false,                 /* partial_inplace */
 977          0,                     /* src_mask */
 978          0xffffffff,            /* dst_mask */
 979          false),                /* pcrel_offset */
 980
 981   UNUSED_RELOC (13),
 982   UNUSED_RELOC (14),
 983   UNUSED_RELOC (15),
 984
 985   /* A 5 bit shift field.  */
 986   HOWTO (R_MIPS_SHIFT5,         /* type */
 987          0,                     /* rightshift */
 988          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          5,                     /* bitsize */
 990          false,                 /* pc_relative */
 991          6,                     /* bitpos */
 992          complain_overflow_bitfield, /* complain_on_overflow */
 993          bfd_elf_generic_reloc, /* special_function */
 994          "R_MIPS_SHIFT5",       /* name */
 995          false,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0x000007c0,            /* dst_mask */
 998          false),                /* pcrel_offset */
 999
1000   /* A 6 bit shift field.  */
1001   HOWTO (R_MIPS_SHIFT6,         /* type */
1002          0,                     /* rightshift */
1003          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1004          6,                     /* bitsize */
1005          false,                 /* pc_relative */
1006          6,                     /* bitpos */
1007          complain_overflow_bitfield, /* complain_on_overflow */
1008          mips_elf64_shift6_reloc, /* special_function */
1009          "R_MIPS_SHIFT6",       /* name */
1010          false,                 /* partial_inplace */
1011          0,                     /* src_mask */
1012          0x000007c4,            /* dst_mask */
1013          false),                /* pcrel_offset */
1014
1015   /* 64 bit relocation.  */
1016   HOWTO (R_MIPS_64,             /* type */
1017          0,                     /* rightshift */
1018          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1019          64,                    /* bitsize */
1020          false,                 /* pc_relative */
1021          0,                     /* bitpos */
1022          complain_overflow_dont, /* complain_on_overflow */
1023          bfd_elf_generic_reloc, /* special_function */
1024          "R_MIPS_64",           /* name */
1025          false,                 /* partial_inplace */
1026          0,                     /* src_mask */
1027          MINUS_ONE,             /* dst_mask */
1028          false),                /* pcrel_offset */
1029
1030   /* Displacement in the global offset table.  */
1031   /* FIXME: Not handled correctly.  */
1032   HOWTO (R_MIPS_GOT_DISP,       /* type */
1033          0,                     /* rightshift */
1034          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1035          16,                    /* bitsize */
1036          false,                 /* pc_relative */
1037          0,                     /* bitpos */
1038          complain_overflow_signed, /* complain_on_overflow */
1039          bfd_elf_generic_reloc, /* special_function */
1040          "R_MIPS_GOT_DISP",     /* name */
1041          false,                 /* partial_inplace */
1042          0,                     /* src_mask */
1043          0x0000ffff,            /* dst_mask */
1044          false),                /* pcrel_offset */
1045
1046   /* Displacement to page pointer in the global offset table.  */
1047   /* FIXME: Not handled correctly.  */
1048   HOWTO (R_MIPS_GOT_PAGE,       /* type */
1049          0,                     /* rightshift */
1050          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1051          16,                    /* bitsize */
1052          false,                 /* pc_relative */
1053          0,                     /* bitpos */
1054          complain_overflow_signed, /* complain_on_overflow */
1055          bfd_elf_generic_reloc, /* special_function */
1056          "R_MIPS_GOT_PAGE",     /* name */
1057          false,                 /* partial_inplace */
1058          0,                     /* src_mask */
1059          0x0000ffff,            /* dst_mask */
1060          false),                /* pcrel_offset */
1061
1062   /* Offset from page pointer in the global offset table.  */
1063   /* FIXME: Not handled correctly.  */
1064   HOWTO (R_MIPS_GOT_OFST,       /* type */
1065          0,                     /* rightshift */
1066          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1067          16,                    /* bitsize */
1068          false,                 /* pc_relative */
1069          0,                     /* bitpos */
1070          complain_overflow_signed, /* complain_on_overflow */
1071          bfd_elf_generic_reloc, /* special_function */
1072          "R_MIPS_GOT_OFST",     /* name */
1073          false,                 /* partial_inplace */
1074          0,                     /* src_mask */
1075          0x0000ffff,            /* dst_mask */
1076          false),                /* pcrel_offset */
1077
1078   /* High 16 bits of displacement in global offset table.  */
1079   /* FIXME: Not handled correctly.  */
1080   HOWTO (R_MIPS_GOT_HI16,       /* type */
1081          0,                     /* rightshift */
1082          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1083          16,                    /* bitsize */
1084          false,                 /* pc_relative */
1085          0,                     /* bitpos */
1086          complain_overflow_dont, /* complain_on_overflow */
1087          bfd_elf_generic_reloc, /* special_function */
1088          "R_MIPS_GOT_HI16",     /* name */
1089          false,                 /* partial_inplace */
1090          0,                     /* src_mask */
1091          0x0000ffff,            /* dst_mask */
1092          false),                /* pcrel_offset */
1093
1094   /* Low 16 bits of displacement in global offset table.  */
1095   /* FIXME: Not handled correctly.  */
1096   HOWTO (R_MIPS_GOT_LO16,       /* type */
1097          0,                     /* rightshift */
1098          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1099          16,                    /* bitsize */
1100          false,                 /* pc_relative */
1101          0,                     /* bitpos */
1102          complain_overflow_dont, /* complain_on_overflow */
1103          bfd_elf_generic_reloc, /* special_function */
1104          "R_MIPS_GOT_LO16",     /* name */
1105          false,                 /* partial_inplace */
1106          0,                     /* src_mask */
1107          0x0000ffff,            /* dst_mask */
1108          false),                /* pcrel_offset */
1109
1110   /* 64 bit substraction.  */
1111   /* FIXME: Not handled correctly.  */
1112   HOWTO (R_MIPS_SUB,            /* type */
1113          0,                     /* rightshift */
1114          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          64,                    /* bitsize */
1116          false,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_dont, /* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_MIPS_SUB",          /* name */
1121          false,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          MINUS_ONE,             /* dst_mask */
1124          false),                /* pcrel_offset */
1125
1126   /* Insert the addend as an instruction.  */
1127   /* FIXME: Not handled correctly.  */
1128   HOWTO (R_MIPS_INSERT_A,       /* type */
1129          0,                     /* rightshift */
1130          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1131          32,                    /* bitsize */
1132          false,                 /* pc_relative */
1133          0,                     /* bitpos */
1134          complain_overflow_dont, /* complain_on_overflow */
1135          bfd_elf_generic_reloc, /* special_function */
1136          "R_MIPS_INSERT_A",     /* name */
1137          false,                 /* partial_inplace */
1138          0,                     /* src_mask */
1139          0xffffffff,            /* dst_mask */
1140          false),                /* pcrel_offset */
1141
1142   /* Insert the addend as an instruction, and change all relocations
1143      to refer to the old instruction at the address.  */
1144   /* FIXME: Not handled correctly.  */
1145   HOWTO (R_MIPS_INSERT_B,       /* type */
1146          0,                     /* rightshift */
1147          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          32,                    /* bitsize */
1149          false,                 /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont, /* complain_on_overflow */
1152          bfd_elf_generic_reloc, /* special_function */
1153          "R_MIPS_INSERT_B",     /* name */
1154          false,                 /* partial_inplace */
1155          0,                     /* src_mask */
1156          0xffffffff,            /* dst_mask */
1157          false),                /* pcrel_offset */
1158
1159   /* Delete a 32 bit instruction.  */
1160   /* FIXME: Not handled correctly.  */
1161   HOWTO (R_MIPS_DELETE,         /* type */
1162          0,                     /* rightshift */
1163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          32,                    /* bitsize */
1165          false,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont, /* complain_on_overflow */
1168          bfd_elf_generic_reloc, /* special_function */
1169          "R_MIPS_DELETE",       /* name */
1170          false,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xffffffff,            /* dst_mask */
1173          false),                /* pcrel_offset */
1174
1175   /* Get the higher value of a 64 bit addend.  */
1176   HOWTO (R_MIPS_HIGHER,         /* type */
1177          0,                     /* rightshift */
1178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          false,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_dont, /* complain_on_overflow */
1183          bfd_elf_generic_reloc, /* special_function */
1184          "R_MIPS_HIGHER",       /* name */
1185          false,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0x0000ffff,            /* dst_mask */
1188          false),                /* pcrel_offset */
1189
1190   /* Get the highest value of a 64 bit addend.  */
1191   HOWTO (R_MIPS_HIGHEST,        /* type */
1192          0,                     /* rightshift */
1193          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          false,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          bfd_elf_generic_reloc, /* special_function */
1199          "R_MIPS_HIGHEST",      /* name */
1200          false,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0x0000ffff,            /* dst_mask */
1203          false),                /* pcrel_offset */
1204
1205   /* High 16 bits of displacement in global offset table.  */
1206   /* FIXME: Not handled correctly.  */
1207   HOWTO (R_MIPS_CALL_HI16,      /* type */
1208          0,                     /* rightshift */
1209          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1210          16,                    /* bitsize */
1211          false,                 /* pc_relative */
1212          0,                     /* bitpos */
1213          complain_overflow_dont, /* complain_on_overflow */
1214          bfd_elf_generic_reloc, /* special_function */
1215          "R_MIPS_CALL_HI16",    /* name */
1216          false,                 /* partial_inplace */
1217          0,                     /* src_mask */
1218          0x0000ffff,            /* dst_mask */
1219          false),                /* pcrel_offset */
1220
1221   /* Low 16 bits of displacement in global offset table.  */
1222   /* FIXME: Not handled correctly.  */
1223   HOWTO (R_MIPS_CALL_LO16,      /* type */
1224          0,                     /* rightshift */
1225          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1226          16,                    /* bitsize */
1227          false,                 /* pc_relative */
1228          0,                     /* bitpos */
1229          complain_overflow_dont, /* complain_on_overflow */
1230          bfd_elf_generic_reloc, /* special_function */
1231          "R_MIPS_CALL_LO16",    /* name */
1232          false,                 /* partial_inplace */
1233          0,                     /* src_mask */
1234          0x0000ffff,            /* dst_mask */
1235          false),                /* pcrel_offset */
1236
1237   /* Section displacement, used by an associated event location section.  */
1238   /* FIXME: Not handled correctly.  */
1239   HOWTO (R_MIPS_SCN_DISP,       /* type */
1240          0,                     /* rightshift */
1241          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1242          32,                    /* bitsize */
1243          false,                 /* pc_relative */
1244          0,                     /* bitpos */
1245          complain_overflow_dont, /* complain_on_overflow */
1246          bfd_elf_generic_reloc, /* special_function */
1247          "R_MIPS_SCN_DISP",     /* name */
1248          false,                 /* partial_inplace */
1249          0,                     /* src_mask */
1250          0xffffffff,            /* dst_mask */
1251          false),                /* pcrel_offset */
1252
1253   HOWTO (R_MIPS_REL16,          /* type */
1254          0,                     /* rightshift */
1255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1256          16,                    /* bitsize */
1257          false,                 /* pc_relative */
1258          0,                     /* bitpos */
1259          complain_overflow_signed, /* complain_on_overflow */
1260          bfd_elf_generic_reloc, /* special_function */
1261          "R_MIPS_REL16",        /* name */
1262          false,                 /* partial_inplace */
1263          0,                     /* src_mask */
1264          0xffff,                /* dst_mask */
1265          false),                /* pcrel_offset */
1266
1267   /* These two are obsolete.  */
1268   EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
1269   EMPTY_HOWTO (R_MIPS_PJUMP),
1270
1271   /* Similiar to R_MIPS_REL32, but used for relocations in a GOT section.
1272      It must be used for multigot GOT's (and only there).  */
1273   HOWTO (R_MIPS_RELGOT,         /* type */
1274          0,                     /* rightshift */
1275          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1276          32,                    /* bitsize */
1277          false,                 /* pc_relative */
1278          0,                     /* bitpos */
1279          complain_overflow_dont, /* complain_on_overflow */
1280          bfd_elf_generic_reloc, /* special_function */
1281          "R_MIPS_RELGOT",       /* name */
1282          false,                 /* partial_inplace */
1283          0,                     /* src_mask */
1284          0xffffffff,            /* dst_mask */
1285          false),                /* pcrel_offset */
1286
1287   /* Protected jump conversion.  This is an optimization hint.  No
1288      relocation is required for correctness.  */
1289   HOWTO (R_MIPS_JALR,           /* type */
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          false,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_MIPS_JALR",         /* name */
1298          false,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0x00000000,            /* dst_mask */
1301          false),                /* pcrel_offset */
1302 };
1303
1304 /* Swap in a MIPS 64-bit Rel reloc.  */
1305
1306 static void
1307 mips_elf64_swap_reloc_in (abfd, src, dst)
1308      bfd *abfd;
1309      const Elf64_Mips_External_Rel *src;
1310      Elf64_Mips_Internal_Rel *dst;
1311 {
1312   dst->r_offset = H_GET_64 (abfd, src->r_offset);
1313   dst->r_sym = H_GET_32 (abfd, src->r_sym);
1314   dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
1315   dst->r_type3 = H_GET_8 (abfd, src->r_type3);
1316   dst->r_type2 = H_GET_8 (abfd, src->r_type2);
1317   dst->r_type = H_GET_8 (abfd, src->r_type);
1318 }
1319
1320 /* Swap in a MIPS 64-bit Rela reloc.  */
1321
1322 static void
1323 mips_elf64_swap_reloca_in (abfd, src, dst)
1324      bfd *abfd;
1325      const Elf64_Mips_External_Rela *src;
1326      Elf64_Mips_Internal_Rela *dst;
1327 {
1328   dst->r_offset = H_GET_64 (abfd, src->r_offset);
1329   dst->r_sym = H_GET_32 (abfd, src->r_sym);
1330   dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
1331   dst->r_type3 = H_GET_8 (abfd, src->r_type3);
1332   dst->r_type2 = H_GET_8 (abfd, src->r_type2);
1333   dst->r_type = H_GET_8 (abfd, src->r_type);
1334   dst->r_addend = H_GET_S64 (abfd, src->r_addend);
1335 }
1336
1337 /* Swap out a MIPS 64-bit Rel reloc.  */
1338
1339 static void
1340 mips_elf64_swap_reloc_out (abfd, src, dst)
1341      bfd *abfd;
1342      const Elf64_Mips_Internal_Rel *src;
1343      Elf64_Mips_External_Rel *dst;
1344 {
1345   H_PUT_64 (abfd, src->r_offset, dst->r_offset);
1346   H_PUT_32 (abfd, src->r_sym, dst->r_sym);
1347   H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
1348   H_PUT_8 (abfd, src->r_type3, dst->r_type3);
1349   H_PUT_8 (abfd, src->r_type2, dst->r_type2);
1350   H_PUT_8 (abfd, src->r_type, dst->r_type);
1351 }
1352
1353 /* Swap out a MIPS 64-bit Rela reloc.  */
1354
1355 static void
1356 mips_elf64_swap_reloca_out (abfd, src, dst)
1357      bfd *abfd;
1358      const Elf64_Mips_Internal_Rela *src;
1359      Elf64_Mips_External_Rela *dst;
1360 {
1361   H_PUT_64 (abfd, src->r_offset, dst->r_offset);
1362   H_PUT_32 (abfd, src->r_sym, dst->r_sym);
1363   H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
1364   H_PUT_8 (abfd, src->r_type3, dst->r_type3);
1365   H_PUT_8 (abfd, src->r_type2, dst->r_type2);
1366   H_PUT_8 (abfd, src->r_type, dst->r_type);
1367   H_PUT_S64 (abfd, src->r_addend, dst->r_addend);
1368 }
1369
1370 /* Swap in a MIPS 64-bit Rel reloc.  */
1371
1372 static void
1373 mips_elf64_be_swap_reloc_in (abfd, src, dst)
1374      bfd *abfd;
1375      const bfd_byte *src;
1376      Elf_Internal_Rel *dst;
1377 {
1378   Elf64_Mips_Internal_Rel mirel;
1379
1380   mips_elf64_swap_reloc_in (abfd,
1381                             (const Elf64_Mips_External_Rel *) src,
1382                             &mirel);
1383
1384   dst[0].r_offset = mirel.r_offset;
1385   dst[0].r_info = ELF64_R_INFO (mirel.r_sym, mirel.r_type);
1386   dst[1].r_offset = mirel.r_offset;
1387   dst[1].r_info = ELF64_R_INFO (mirel.r_ssym, mirel.r_type2);
1388   dst[2].r_offset = mirel.r_offset;
1389   dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirel.r_type3);
1390 }
1391
1392 /* Swap in a MIPS 64-bit Rela reloc.  */
1393
1394 static void
1395 mips_elf64_be_swap_reloca_in (abfd, src, dst)
1396      bfd *abfd;
1397      const bfd_byte *src;
1398      Elf_Internal_Rela *dst;
1399 {
1400   Elf64_Mips_Internal_Rela mirela;
1401
1402   mips_elf64_swap_reloca_in (abfd,
1403                              (const Elf64_Mips_External_Rela *) src,
1404                              &mirela);
1405
1406   dst[0].r_offset = mirela.r_offset;
1407   dst[0].r_info = ELF64_R_INFO (mirela.r_sym, mirela.r_type);
1408   dst[0].r_addend = mirela.r_addend;
1409   dst[1].r_offset = mirela.r_offset;
1410   dst[1].r_info = ELF64_R_INFO (mirela.r_ssym, mirela.r_type2);
1411   dst[1].r_addend = 0;
1412   dst[2].r_offset = mirela.r_offset;
1413   dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirela.r_type3);
1414   dst[2].r_addend = 0;
1415 }
1416
1417 /* Swap out a MIPS 64-bit Rel reloc.  */
1418
1419 static void
1420 mips_elf64_be_swap_reloc_out (abfd, src, dst)
1421      bfd *abfd;
1422      const Elf_Internal_Rel *src;
1423      bfd_byte *dst;
1424 {
1425   Elf64_Mips_Internal_Rel mirel;
1426
1427   mirel.r_offset = src[0].r_offset;
1428   BFD_ASSERT(src[0].r_offset == src[1].r_offset);
1429   BFD_ASSERT(src[0].r_offset == src[2].r_offset);
1430
1431   mirel.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
1432   mirel.r_sym = ELF64_R_SYM (src[0].r_info);
1433   mirel.r_type2 = ELF64_MIPS_R_TYPE2 (src[1].r_info);
1434   mirel.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
1435   mirel.r_type3 = ELF64_MIPS_R_TYPE3 (src[2].r_info);
1436
1437   mips_elf64_swap_reloc_out (abfd, &mirel,
1438                              (Elf64_Mips_External_Rel *) dst);
1439 }
1440
1441 /* Swap out a MIPS 64-bit Rela reloc.  */
1442
1443 static void
1444 mips_elf64_be_swap_reloca_out (abfd, src, dst)
1445      bfd *abfd;
1446      const Elf_Internal_Rela *src;
1447      bfd_byte *dst;
1448 {
1449   Elf64_Mips_Internal_Rela mirela;
1450
1451   mirela.r_offset = src[0].r_offset;
1452   BFD_ASSERT(src[0].r_offset == src[1].r_offset);
1453   BFD_ASSERT(src[0].r_offset == src[2].r_offset);
1454
1455   mirela.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
1456   mirela.r_sym = ELF64_R_SYM (src[0].r_info);
1457   mirela.r_addend = src[0].r_addend;
1458   BFD_ASSERT(src[1].r_addend == 0);
1459   BFD_ASSERT(src[2].r_addend == 0);
1460
1461   mirela.r_type2 = ELF64_MIPS_R_TYPE2 (src[1].r_info);
1462   mirela.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
1463   mirela.r_type3 = ELF64_MIPS_R_TYPE3 (src[2].r_info);
1464
1465   mips_elf64_swap_reloca_out (abfd, &mirela,
1466                               (Elf64_Mips_External_Rela *) dst);
1467 }
1468
1469 /* Calculate the %high function.  */
1470
1471 static bfd_vma
1472 mips_elf64_high (value)
1473      bfd_vma value;
1474 {
1475   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
1476 }
1477
1478 /* Calculate the %higher function.  */
1479
1480 static bfd_vma
1481 mips_elf64_higher (value)
1482      bfd_vma value;
1483 {
1484   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
1485 }
1486
1487 /* Calculate the %highest function.  */
1488
1489 static bfd_vma
1490 mips_elf64_highest (value)
1491      bfd_vma value;
1492 {
1493   return ((value + (bfd_vma) 0x800080008000) >> 48) & 0xffff;
1494 }
1495
1496 /* Do a R_MIPS_HI16 relocation.  */
1497
1498 bfd_reloc_status_type
1499 mips_elf64_hi16_reloc (abfd,
1500                      reloc_entry,
1501                      symbol,
1502                      data,
1503                      input_section,
1504                      output_bfd,
1505                      error_message)
1506      bfd *abfd ATTRIBUTE_UNUSED;
1507      arelent *reloc_entry;
1508      asymbol *symbol;
1509      PTR data ATTRIBUTE_UNUSED;
1510      asection *input_section;
1511      bfd *output_bfd;
1512      char **error_message ATTRIBUTE_UNUSED;
1513 {
1514   /* If we're relocating, and this is an external symbol, we don't
1515      want to change anything.  */
1516   if (output_bfd != (bfd *) NULL
1517       && (symbol->flags & BSF_SECTION_SYM) == 0
1518       && (! reloc_entry->howto->partial_inplace
1519           || reloc_entry->addend == 0))
1520     {
1521       reloc_entry->address += input_section->output_offset;
1522       return bfd_reloc_ok;
1523     }
1524
1525   if (((reloc_entry->addend & 0xffff) + 0x8000) & ~0xffff)
1526     reloc_entry->addend += 0x8000;
1527
1528   return bfd_reloc_continue;
1529 }
1530
1531 /* Do a R_MIPS_HIGHER relocation.  */
1532
1533 bfd_reloc_status_type
1534 mips_elf64_higher_reloc (abfd,
1535                          reloc_entry,
1536                          symbol,
1537                          data,
1538                          input_section,
1539                          output_bfd,
1540                          error_message)
1541      bfd *abfd ATTRIBUTE_UNUSED;
1542      arelent *reloc_entry;
1543      asymbol *symbol;
1544      PTR data ATTRIBUTE_UNUSED;
1545      asection *input_section;
1546      bfd *output_bfd;
1547      char **error_message ATTRIBUTE_UNUSED;
1548 {
1549   /* If we're relocating, and this is an external symbol, we don't
1550      want to change anything.  */
1551   if (output_bfd != (bfd *) NULL
1552       && (symbol->flags & BSF_SECTION_SYM) == 0
1553       && (! reloc_entry->howto->partial_inplace
1554           || reloc_entry->addend == 0))
1555     {
1556       reloc_entry->address += input_section->output_offset;
1557       return bfd_reloc_ok;
1558     }
1559
1560   if (((reloc_entry->addend & 0xffffffff) + 0x80008000)
1561       & ~0xffffffff)
1562     reloc_entry->addend += 0x80008000;
1563
1564   return bfd_reloc_continue;
1565 }
1566
1567 /* Do a R_MIPS_HIGHEST relocation.  */
1568
1569 bfd_reloc_status_type
1570 mips_elf64_highest_reloc (abfd,
1571                           reloc_entry,
1572                           symbol,
1573                           data,
1574                           input_section,
1575                           output_bfd,
1576                           error_message)
1577      bfd *abfd ATTRIBUTE_UNUSED;
1578      arelent *reloc_entry;
1579      asymbol *symbol;
1580      PTR data ATTRIBUTE_UNUSED;
1581      asection *input_section;
1582      bfd *output_bfd;
1583      char **error_message ATTRIBUTE_UNUSED;
1584 {
1585   /* If we're relocating, and this is an external symbol, we don't
1586      want to change anything.  */
1587   if (output_bfd != (bfd *) NULL
1588       && (symbol->flags & BSF_SECTION_SYM) == 0
1589       && (! reloc_entry->howto->partial_inplace
1590           || reloc_entry->addend == 0))
1591     {
1592       reloc_entry->address += input_section->output_offset;
1593       return bfd_reloc_ok;
1594     }
1595
1596   if (((reloc_entry->addend & 0xffffffffffff) + 0x800080008000)
1597       & ~0xffffffffffff)
1598     reloc_entry->addend += 0x800080008000;
1599
1600   return bfd_reloc_continue;
1601 }
1602
1603 /* Do a R_MIPS_GOT16 reloc.  This is a reloc against the global offset
1604    table used for PIC code.  If the symbol is an external symbol, the
1605    instruction is modified to contain the offset of the appropriate
1606    entry in the global offset table.  If the symbol is a section
1607    symbol, the next reloc is a R_MIPS_LO16 reloc.  The two 16 bit
1608    addends are combined to form the real addend against the section
1609    symbol; the GOT16 is modified to contain the offset of an entry in
1610    the global offset table, and the LO16 is modified to offset it
1611    appropriately.  Thus an offset larger than 16 bits requires a
1612    modified value in the global offset table.
1613
1614    This implementation suffices for the assembler, but the linker does
1615    not yet know how to create global offset tables.  */
1616
1617 bfd_reloc_status_type
1618 mips_elf64_got16_reloc (abfd,
1619                       reloc_entry,
1620                       symbol,
1621                       data,
1622                       input_section,
1623                       output_bfd,
1624                       error_message)
1625      bfd *abfd;
1626      arelent *reloc_entry;
1627      asymbol *symbol;
1628      PTR data;
1629      asection *input_section;
1630      bfd *output_bfd;
1631      char **error_message;
1632 {
1633   /* If we're relocating, and this an external symbol, we don't want
1634      to change anything.  */
1635   if (output_bfd != (bfd *) NULL
1636       && (symbol->flags & BSF_SECTION_SYM) == 0
1637       && reloc_entry->addend == 0)
1638     {
1639       reloc_entry->address += input_section->output_offset;
1640       return bfd_reloc_ok;
1641     }
1642
1643   /* If we're relocating, and this is a local symbol, we can handle it
1644      just like HI16.  */
1645   if (output_bfd != (bfd *) NULL
1646       && (symbol->flags & BSF_SECTION_SYM) != 0)
1647     return mips_elf64_hi16_reloc (abfd, reloc_entry, symbol, data,
1648                                   input_section, output_bfd, error_message);
1649
1650   abort ();
1651 }
1652
1653 /* Set the GP value for OUTPUT_BFD.  Returns false if this is a
1654    dangerous relocation.  */
1655
1656 static boolean
1657 mips_elf64_assign_gp (output_bfd, pgp)
1658      bfd *output_bfd;
1659      bfd_vma *pgp;
1660 {
1661   unsigned int count;
1662   asymbol **sym;
1663   unsigned int i;
1664
1665   /* If we've already figured out what GP will be, just return it.  */
1666   *pgp = _bfd_get_gp_value (output_bfd);
1667   if (*pgp)
1668     return true;
1669
1670   count = bfd_get_symcount (output_bfd);
1671   sym = bfd_get_outsymbols (output_bfd);
1672
1673   /* The linker script will have created a symbol named `_gp' with the
1674      appropriate value.  */
1675   if (sym == (asymbol **) NULL)
1676     i = count;
1677   else
1678     {
1679       for (i = 0; i < count; i++, sym++)
1680         {
1681           register CONST char *name;
1682
1683           name = bfd_asymbol_name (*sym);
1684           if (*name == '_' && strcmp (name, "_gp") == 0)
1685             {
1686               *pgp = bfd_asymbol_value (*sym);
1687               _bfd_set_gp_value (output_bfd, *pgp);
1688               break;
1689             }
1690         }
1691     }
1692
1693   if (i >= count)
1694     {
1695       /* Only get the error once.  */
1696       *pgp = 4;
1697       _bfd_set_gp_value (output_bfd, *pgp);
1698       return false;
1699     }
1700
1701   return true;
1702 }
1703
1704 /* We have to figure out the gp value, so that we can adjust the
1705    symbol value correctly.  We look up the symbol _gp in the output
1706    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1707    target data.  We don't need to adjust the symbol value for an
1708    external symbol if we are producing relocateable output.  */
1709
1710 static bfd_reloc_status_type
1711 mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1712      bfd *output_bfd;
1713      asymbol *symbol;
1714      boolean relocateable;
1715      char **error_message;
1716      bfd_vma *pgp;
1717 {
1718   if (bfd_is_und_section (symbol->section)
1719       && ! relocateable)
1720     {
1721       *pgp = 0;
1722       return bfd_reloc_undefined;
1723     }
1724
1725   *pgp = _bfd_get_gp_value (output_bfd);
1726   if (*pgp == 0
1727       && (! relocateable
1728           || (symbol->flags & BSF_SECTION_SYM) != 0))
1729     {
1730       if (relocateable)
1731         {
1732           /* Make up a value.  */
1733           *pgp = symbol->section->output_section->vma + 0x4000;
1734           _bfd_set_gp_value (output_bfd, *pgp);
1735         }
1736       else if (!mips_elf64_assign_gp (output_bfd, pgp))
1737         {
1738           *error_message =
1739             (char *) _("GP relative relocation when _gp not defined");
1740           return bfd_reloc_dangerous;
1741         }
1742     }
1743
1744   return bfd_reloc_ok;
1745 }
1746
1747 /* Do a R_MIPS_GPREL16 relocation.  This is a 16 bit value which must
1748    become the offset from the gp register.  */
1749
1750 bfd_reloc_status_type
1751 mips_elf64_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1752                           output_bfd, error_message)
1753      bfd *abfd;
1754      arelent *reloc_entry;
1755      asymbol *symbol;
1756      PTR data;
1757      asection *input_section;
1758      bfd *output_bfd;
1759      char **error_message;
1760 {
1761   boolean relocateable;
1762   bfd_reloc_status_type ret;
1763   bfd_vma gp;
1764
1765   /* If we're relocating, and this is an external symbol with no
1766      addend, we don't want to change anything.  We will only have an
1767      addend if this is a newly created reloc, not read from an ELF
1768      file.  */
1769   if (output_bfd != (bfd *) NULL
1770       && (symbol->flags & BSF_SECTION_SYM) == 0
1771       && reloc_entry->addend == 0)
1772     {
1773       reloc_entry->address += input_section->output_offset;
1774       return bfd_reloc_ok;
1775     }
1776
1777   if (output_bfd != (bfd *) NULL)
1778     relocateable = true;
1779   else
1780     {
1781       relocateable = false;
1782       output_bfd = symbol->section->output_section->owner;
1783     }
1784
1785   ret = mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message,
1786                              &gp);
1787   if (ret != bfd_reloc_ok)
1788     return ret;
1789
1790   return gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1791                           relocateable, data, gp);
1792 }
1793
1794 static bfd_reloc_status_type
1795 gprel16_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1796                  gp)
1797      bfd *abfd;
1798      asymbol *symbol;
1799      arelent *reloc_entry;
1800      asection *input_section;
1801      boolean relocateable;
1802      PTR data;
1803      bfd_vma gp;
1804 {
1805   bfd_vma relocation;
1806   unsigned long insn;
1807   unsigned long val;
1808
1809   if (bfd_is_com_section (symbol->section))
1810     relocation = 0;
1811   else
1812     relocation = symbol->value;
1813
1814   relocation += symbol->section->output_section->vma;
1815   relocation += symbol->section->output_offset;
1816
1817   if (reloc_entry->address > input_section->_cooked_size)
1818     return bfd_reloc_outofrange;
1819
1820   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1821
1822   /* Set val to the offset into the section or symbol.  */
1823   if (reloc_entry->howto->src_mask == 0)
1824     {
1825       /* This case occurs with the 64-bit MIPS ELF ABI.  */
1826       val = reloc_entry->addend;
1827     }
1828   else
1829     {
1830       val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
1831       if (val & 0x8000)
1832         val -= 0x10000;
1833     }
1834
1835   /* Adjust val for the final section location and GP value.  If we
1836      are producing relocateable output, we don't want to do this for
1837      an external symbol.  */
1838   if (! relocateable
1839       || (symbol->flags & BSF_SECTION_SYM) != 0)
1840     val += relocation - gp;
1841
1842   insn = (insn & ~0xffff) | (val & 0xffff);
1843   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1844
1845   if (relocateable)
1846     reloc_entry->address += input_section->output_offset;
1847
1848   else if ((long) val >= 0x8000 || (long) val < -0x8000)
1849     return bfd_reloc_overflow;
1850
1851   return bfd_reloc_ok;
1852 }
1853
1854 /* Do a R_MIPS_GPREL16 RELA relocation.  */
1855
1856 bfd_reloc_status_type
1857 mips_elf64_gprel16_reloca (abfd, reloc_entry, symbol, data, input_section,
1858                            output_bfd, error_message)
1859      bfd *abfd;
1860      arelent *reloc_entry;
1861      asymbol *symbol;
1862      PTR data ATTRIBUTE_UNUSED;
1863      asection *input_section;
1864      bfd *output_bfd;
1865      char **error_message;
1866 {
1867   boolean relocateable;
1868   bfd_vma gp;
1869
1870   /* This works only for NewABI.  */
1871   BFD_ASSERT (reloc_entry->howto->src_mask == 0);
1872
1873   /* If we're relocating, and this is an external symbol with no
1874      addend, we don't want to change anything.  We will only have an
1875      addend if this is a newly created reloc, not read from an ELF
1876      file.  */
1877   if (output_bfd != (bfd *) NULL
1878       && (symbol->flags & BSF_SECTION_SYM) == 0
1879       && reloc_entry->addend == 0)
1880     {
1881       reloc_entry->address += input_section->output_offset;
1882       return bfd_reloc_ok;
1883     }
1884
1885   if (output_bfd != (bfd *) NULL)
1886     relocateable = true;
1887   else
1888     {
1889       relocateable = false;
1890       output_bfd = symbol->section->output_section->owner;
1891     }
1892
1893   if (prev_reloc_address != reloc_entry->address)
1894     prev_reloc_address = reloc_entry->address;
1895   else
1896     {
1897       mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message,
1898                            &gp);
1899       prev_reloc_addend = reloc_entry->addend + reloc_entry->address - gp;
1900       if (symbol->flags & BSF_LOCAL)
1901         prev_reloc_addend += _bfd_get_gp_value (abfd);
1902 /*fprintf(stderr, "Addend: %lx, Next Addend: %lx\n", reloc_entry->addend, prev_reloc_addend);*/
1903     }
1904
1905   return bfd_reloc_ok;
1906 }
1907
1908 /* Do a R_MIPS_LITERAL relocation.  */
1909
1910 bfd_reloc_status_type
1911 mips_elf64_literal_reloc (abfd, reloc_entry, symbol, data, input_section,
1912                           output_bfd, error_message)
1913      bfd *abfd;
1914      arelent *reloc_entry;
1915      asymbol *symbol;
1916      PTR data;
1917      asection *input_section;
1918      bfd *output_bfd;
1919      char **error_message;
1920 {
1921   /* If we're relocating, and this is an external symbol, we don't
1922      want to change anything.  */
1923   if (output_bfd != (bfd *) NULL
1924       && (symbol->flags & BSF_SECTION_SYM) == 0
1925       && (! reloc_entry->howto->partial_inplace
1926           || reloc_entry->addend == 0))
1927     {
1928       reloc_entry->address += input_section->output_offset;
1929       return bfd_reloc_ok;
1930     }
1931
1932   /* FIXME: The entries in the .lit8 and .lit4 sections should be merged.
1933      Currently we simply call mips_elf64_gprel16_reloc.  */
1934   return mips_elf64_gprel16_reloc (abfd, reloc_entry, symbol, data,
1935                                    input_section, output_bfd, error_message);
1936 }
1937
1938 /* Do a R_MIPS_GPREL32 relocation.  Is this 32 bit value the offset
1939    from the gp register? XXX */
1940
1941 bfd_reloc_status_type
1942 mips_elf64_gprel32_reloc (abfd,
1943                         reloc_entry,
1944                         symbol,
1945                         data,
1946                         input_section,
1947                         output_bfd,
1948                         error_message)
1949      bfd *abfd;
1950      arelent *reloc_entry;
1951      asymbol *symbol;
1952      PTR data;
1953      asection *input_section;
1954      bfd *output_bfd;
1955      char **error_message;
1956 {
1957   boolean relocateable;
1958   bfd_reloc_status_type ret;
1959   bfd_vma gp;
1960   bfd_vma relocation;
1961   unsigned long val;
1962
1963   /* If we're relocating, and this is an external symbol with no
1964      addend, we don't want to change anything.  We will only have an
1965      addend if this is a newly created reloc, not read from an ELF
1966      file.  */
1967   if (output_bfd != (bfd *) NULL
1968       && (symbol->flags & BSF_SECTION_SYM) == 0
1969       && reloc_entry->addend == 0)
1970     {
1971       *error_message = (char *)
1972         _("32bits gp relative relocation occurs for an external symbol");
1973       return bfd_reloc_outofrange;
1974     }
1975
1976   if (output_bfd != (bfd *) NULL)
1977     {
1978       relocateable = true;
1979       gp = _bfd_get_gp_value (output_bfd);
1980     }
1981   else
1982     {
1983       relocateable = false;
1984       output_bfd = symbol->section->output_section->owner;
1985
1986       ret = mips_elf64_final_gp (output_bfd, symbol, relocateable,
1987                                  error_message, &gp);
1988       if (ret != bfd_reloc_ok)
1989         return ret;
1990     }
1991
1992   if (bfd_is_com_section (symbol->section))
1993     relocation = 0;
1994   else
1995     relocation = symbol->value;
1996
1997   relocation += symbol->section->output_section->vma;
1998   relocation += symbol->section->output_offset;
1999
2000   if (reloc_entry->address > input_section->_cooked_size)
2001     return bfd_reloc_outofrange;
2002
2003   if (reloc_entry->howto->src_mask == 0)
2004     {
2005       /* This case arises with the 64-bit MIPS ELF ABI.  */
2006       val = 0;
2007     }
2008   else
2009     val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
2010
2011   /* Set val to the offset into the section or symbol.  */
2012   val += reloc_entry->addend;
2013
2014   /* Adjust val for the final section location and GP value.  If we
2015      are producing relocateable output, we don't want to do this for
2016      an external symbol.  */
2017   if (! relocateable
2018       || (symbol->flags & BSF_SECTION_SYM) != 0)
2019     val += relocation - gp;
2020
2021   bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
2022
2023   if (relocateable)
2024     reloc_entry->address += input_section->output_offset;
2025
2026   return bfd_reloc_ok;
2027 }
2028
2029 /* Do a R_MIPS_SHIFT6 relocation. The MSB of the shift is stored at bit 2,
2030    the rest is at bits 6-10. The bitpos alredy got right by the howto.   */
2031
2032 bfd_reloc_status_type
2033 mips_elf64_shift6_reloc (abfd, reloc_entry, symbol, data, input_section,
2034                          output_bfd, error_message)
2035      bfd *abfd ATTRIBUTE_UNUSED;
2036      arelent *reloc_entry;
2037      asymbol *symbol;
2038      PTR data ATTRIBUTE_UNUSED;
2039      asection *input_section;
2040      bfd *output_bfd;
2041      char **error_message ATTRIBUTE_UNUSED;
2042 {
2043   /* If we're relocating, and this is an external symbol, we don't
2044      want to change anything.  */
2045   if (output_bfd != (bfd *) NULL
2046       && (symbol->flags & BSF_SECTION_SYM) == 0
2047       && (! reloc_entry->howto->partial_inplace
2048           || reloc_entry->addend == 0))
2049     {
2050       reloc_entry->address += input_section->output_offset;
2051       return bfd_reloc_ok;
2052     }
2053
2054   reloc_entry->addend = (reloc_entry->addend & 0x00007c0)
2055                         | (reloc_entry->addend & 0x00000800) >> 9;
2056
2057   return bfd_reloc_continue;
2058 }
2059
2060 static int
2061 mips_elf64_additional_program_headers (abfd)
2062      bfd *abfd;
2063 {
2064   int ret = 0;
2065
2066   /* See if we need a PT_MIPS_OPTIONS segment.  */
2067   if (bfd_get_section_by_name (abfd, ".MIPS.options"))
2068     ++ret;
2069
2070   return ret;
2071 }
2072
2073 /* Given a BFD reloc type, return a howto structure.  */
2074
2075 static reloc_howto_type *
2076 mips_elf64_reloc_type_lookup (abfd, code)
2077      bfd *abfd ATTRIBUTE_UNUSED;
2078      bfd_reloc_code_real_type code;
2079 {
2080   /* FIXME: We default to RELA here instead of choosing the right
2081      relocation variant.  */
2082   reloc_howto_type *howto_table = mips_elf64_howto_table_rela;
2083
2084   switch (code)
2085     {
2086     case BFD_RELOC_NONE:
2087       return &howto_table[R_MIPS_NONE];
2088     case BFD_RELOC_16:
2089       return &howto_table[R_MIPS_16];
2090     case BFD_RELOC_32:
2091       return &howto_table[R_MIPS_32];
2092     case BFD_RELOC_64:
2093     case BFD_RELOC_CTOR:
2094       /* We need to handle these specially.  Select the right
2095          relocation (R_MIPS_32 or R_MIPS_64) based on the
2096          size of addresses on this architecture.  */
2097       if (bfd_arch_bits_per_address (abfd) == 32)
2098         return &howto_table[R_MIPS_32];
2099       else
2100         return &howto_table[R_MIPS_64];
2101
2102     case BFD_RELOC_16_PCREL:
2103       return &howto_table[R_MIPS_PC16];
2104     case BFD_RELOC_HI16_S:
2105       return &howto_table[R_MIPS_HI16];
2106     case BFD_RELOC_LO16:
2107       return &howto_table[R_MIPS_LO16];
2108     case BFD_RELOC_GPREL16:
2109       return &howto_table[R_MIPS_GPREL16];
2110     case BFD_RELOC_GPREL32:
2111       return &howto_table[R_MIPS_GPREL32];
2112     case BFD_RELOC_MIPS_JMP:
2113       return &howto_table[R_MIPS_26];
2114     case BFD_RELOC_MIPS_LITERAL:
2115       return &howto_table[R_MIPS_LITERAL];
2116     case BFD_RELOC_MIPS_GOT16:
2117       return &howto_table[R_MIPS_GOT16];
2118     case BFD_RELOC_MIPS_CALL16:
2119       return &howto_table[R_MIPS_CALL16];
2120     case BFD_RELOC_MIPS_SHIFT5:
2121       return &howto_table[R_MIPS_SHIFT5];
2122     case BFD_RELOC_MIPS_SHIFT6:
2123       return &howto_table[R_MIPS_SHIFT6];
2124     case BFD_RELOC_MIPS_GOT_DISP:
2125       return &howto_table[R_MIPS_GOT_DISP];
2126     case BFD_RELOC_MIPS_GOT_PAGE:
2127       return &howto_table[R_MIPS_GOT_PAGE];
2128     case BFD_RELOC_MIPS_GOT_OFST:
2129       return &howto_table[R_MIPS_GOT_OFST];
2130     case BFD_RELOC_MIPS_GOT_HI16:
2131       return &howto_table[R_MIPS_GOT_HI16];
2132     case BFD_RELOC_MIPS_GOT_LO16:
2133       return &howto_table[R_MIPS_GOT_LO16];
2134     case BFD_RELOC_MIPS_SUB:
2135       return &howto_table[R_MIPS_SUB];
2136     case BFD_RELOC_MIPS_INSERT_A:
2137       return &howto_table[R_MIPS_INSERT_A];
2138     case BFD_RELOC_MIPS_INSERT_B:
2139       return &howto_table[R_MIPS_INSERT_B];
2140     case BFD_RELOC_MIPS_DELETE:
2141       return &howto_table[R_MIPS_DELETE];
2142     case BFD_RELOC_MIPS_HIGHEST:
2143       return &howto_table[R_MIPS_HIGHEST];
2144     case BFD_RELOC_MIPS_HIGHER:
2145       return &howto_table[R_MIPS_HIGHER];
2146     case BFD_RELOC_MIPS_CALL_HI16:
2147       return &howto_table[R_MIPS_CALL_HI16];
2148     case BFD_RELOC_MIPS_CALL_LO16:
2149       return &howto_table[R_MIPS_CALL_LO16];
2150     case BFD_RELOC_MIPS_SCN_DISP:
2151       return &howto_table[R_MIPS_SCN_DISP];
2152     case BFD_RELOC_MIPS_REL16:
2153       return &howto_table[R_MIPS_REL16];
2154     /* Use of R_MIPS_ADD_IMMEDIATE and R_MIPS_PJUMP is deprecated.  */
2155     case BFD_RELOC_MIPS_RELGOT:
2156       return &howto_table[R_MIPS_RELGOT];
2157     case BFD_RELOC_MIPS_JALR:
2158       return &howto_table[R_MIPS_JALR];
2159 /*
2160     case BFD_RELOC_MIPS16_JMP:
2161       return &elf_mips16_jump_howto;
2162     case BFD_RELOC_MIPS16_GPREL:
2163       return &elf_mips16_gprel_howto;
2164     case BFD_RELOC_VTABLE_INHERIT:
2165       return &elf_mips_gnu_vtinherit_howto;
2166     case BFD_RELOC_VTABLE_ENTRY:
2167       return &elf_mips_gnu_vtentry_howto;
2168     case BFD_RELOC_PCREL_HI16_S:
2169       return &elf_mips_gnu_rel_hi16;
2170     case BFD_RELOC_PCREL_LO16:
2171       return &elf_mips_gnu_rel_lo16;
2172     case BFD_RELOC_16_PCREL_S2:
2173       return &elf_mips_gnu_rel16_s2;
2174     case BFD_RELOC_64_PCREL:
2175       return &elf_mips_gnu_pcrel64;
2176     case BFD_RELOC_32_PCREL:
2177       return &elf_mips_gnu_pcrel32;
2178 */
2179     default:
2180       bfd_set_error (bfd_error_bad_value);
2181       return NULL;
2182     }
2183 }
2184
2185 /* Prevent relocation handling by bfd for MIPS ELF64.  */
2186
2187 static void
2188 mips_elf64_info_to_howto_rel (abfd, cache_ptr, dst)
2189      bfd *abfd ATTRIBUTE_UNUSED;
2190      arelent *cache_ptr ATTRIBUTE_UNUSED;
2191      Elf64_Internal_Rel *dst ATTRIBUTE_UNUSED;
2192 {
2193   BFD_ASSERT (0);
2194 }
2195
2196 static void
2197 mips_elf64_info_to_howto_rela (abfd, cache_ptr, dst)
2198      bfd *abfd ATTRIBUTE_UNUSED;
2199      arelent *cache_ptr ATTRIBUTE_UNUSED;
2200      Elf64_Internal_Rela *dst ATTRIBUTE_UNUSED;
2201 {
2202   BFD_ASSERT (0);
2203 }
2204
2205 /* Since each entry in an SHT_REL or SHT_RELA section can represent up
2206    to three relocs, we must tell the user to allocate more space.  */
2207
2208 static long
2209 mips_elf64_get_reloc_upper_bound (abfd, sec)
2210      bfd *abfd ATTRIBUTE_UNUSED;
2211      asection *sec;
2212 {
2213   return (sec->reloc_count * 3 + 1) * sizeof (arelent *);
2214 }
2215
2216 /* Read the relocations from one reloc section.  */
2217
2218 static boolean
2219 mips_elf64_slurp_one_reloc_table (abfd, asect, symbols, rel_hdr)
2220      bfd *abfd;
2221      asection *asect;
2222      asymbol **symbols;
2223      const Elf_Internal_Shdr *rel_hdr;
2224 {
2225   PTR allocated = NULL;
2226   bfd_byte *native_relocs;
2227   arelent *relents;
2228   arelent *relent;
2229   bfd_vma count;
2230   bfd_vma i;
2231   int entsize;
2232   reloc_howto_type *howto_table;
2233
2234   allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
2235   if (allocated == NULL)
2236     return false;
2237
2238   if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
2239       || (bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size))
2240     goto error_return;
2241
2242   native_relocs = (bfd_byte *) allocated;
2243
2244   relents = asect->relocation + asect->reloc_count;
2245
2246   entsize = rel_hdr->sh_entsize;
2247   BFD_ASSERT (entsize == sizeof (Elf64_Mips_External_Rel)
2248               || entsize == sizeof (Elf64_Mips_External_Rela));
2249
2250   count = rel_hdr->sh_size / entsize;
2251
2252   if (entsize == sizeof (Elf64_Mips_External_Rel))
2253     howto_table = mips_elf64_howto_table_rel;
2254   else
2255     howto_table = mips_elf64_howto_table_rela;
2256
2257   relent = relents;
2258   for (i = 0; i < count; i++, native_relocs += entsize)
2259     {
2260       Elf64_Mips_Internal_Rela rela;
2261       boolean used_sym, used_ssym;
2262       int ir;
2263
2264       if (entsize == sizeof (Elf64_Mips_External_Rela))
2265         mips_elf64_swap_reloca_in (abfd,
2266                                    (Elf64_Mips_External_Rela *) native_relocs,
2267                                    &rela);
2268       else
2269         {
2270           Elf64_Mips_Internal_Rel rel;
2271
2272           mips_elf64_swap_reloc_in (abfd,
2273                                     (Elf64_Mips_External_Rel *) native_relocs,
2274                                     &rel);
2275           rela.r_offset = rel.r_offset;
2276           rela.r_sym = rel.r_sym;
2277           rela.r_ssym = rel.r_ssym;
2278           rela.r_type3 = rel.r_type3;
2279           rela.r_type2 = rel.r_type2;
2280           rela.r_type = rel.r_type;
2281           rela.r_addend = 0;
2282         }
2283
2284       /* Each entry represents up to three actual relocations.  */
2285
2286       used_sym = false;
2287       used_ssym = false;
2288       for (ir = 0; ir < 3; ir++)
2289         {
2290           enum elf_mips_reloc_type type;
2291
2292           switch (ir)
2293             {
2294             default:
2295               abort ();
2296             case 0:
2297               type = (enum elf_mips_reloc_type) rela.r_type;
2298               break;
2299             case 1:
2300               type = (enum elf_mips_reloc_type) rela.r_type2;
2301               break;
2302             case 2:
2303               type = (enum elf_mips_reloc_type) rela.r_type3;
2304               break;
2305             }
2306
2307           if (type == R_MIPS_NONE)
2308             {
2309               /* There are no more relocations in this entry.  If this
2310                  is the first entry, we need to generate a dummy
2311                  relocation so that the generic linker knows that
2312                  there has been a break in the sequence of relocations
2313                  applying to a particular address.  */
2314               if (ir == 0)
2315                 {
2316                   relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2317                   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2318                     relent->address = rela.r_offset;
2319                   else
2320                     relent->address = rela.r_offset - asect->vma;
2321                   relent->addend = 0;
2322                   relent->howto = &howto_table[(int) R_MIPS_NONE];
2323                   ++relent;
2324                 }
2325               break;
2326             }
2327
2328           /* Some types require symbols, whereas some do not.  */
2329           switch (type)
2330             {
2331             case R_MIPS_NONE:
2332             case R_MIPS_LITERAL:
2333             case R_MIPS_INSERT_A:
2334             case R_MIPS_INSERT_B:
2335             case R_MIPS_DELETE:
2336               relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2337               break;
2338
2339             default:
2340               if (! used_sym)
2341                 {
2342                   if (rela.r_sym == 0)
2343                     relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2344                   else
2345                     {
2346                       asymbol **ps, *s;
2347
2348                       ps = symbols + rela.r_sym - 1;
2349                       s = *ps;
2350                       if ((s->flags & BSF_SECTION_SYM) == 0)
2351                         relent->sym_ptr_ptr = ps;
2352                       else
2353                         relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2354                     }
2355
2356                   used_sym = true;
2357                 }
2358               else if (! used_ssym)
2359                 {
2360                   switch (rela.r_ssym)
2361                     {
2362                     case RSS_UNDEF:
2363                       relent->sym_ptr_ptr =
2364                         bfd_abs_section_ptr->symbol_ptr_ptr;
2365                       break;
2366
2367                     case RSS_GP:
2368                     case RSS_GP0:
2369                     case RSS_LOC:
2370                       /* FIXME: I think these need to be handled using
2371                          special howto structures.  */
2372                       BFD_ASSERT (0);
2373                       break;
2374
2375                     default:
2376                       BFD_ASSERT (0);
2377                       break;
2378                     }
2379
2380                   used_ssym = true;
2381                 }
2382               else
2383                 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2384
2385               break;
2386             }
2387
2388           /* The address of an ELF reloc is section relative for an
2389              object file, and absolute for an executable file or
2390              shared library.  The address of a BFD reloc is always
2391              section relative.  */
2392           if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2393             relent->address = rela.r_offset;
2394           else
2395             relent->address = rela.r_offset - asect->vma;
2396
2397           relent->addend = rela.r_addend;
2398
2399           relent->howto = &howto_table[(int) type];
2400
2401           ++relent;
2402         }
2403     }
2404
2405   asect->reloc_count += relent - relents;
2406
2407   if (allocated != NULL)
2408     free (allocated);
2409
2410   return true;
2411
2412  error_return:
2413   if (allocated != NULL)
2414     free (allocated);
2415   return false;
2416 }
2417
2418 /* Read the relocations.  On Irix 6, there can be two reloc sections
2419    associated with a single data section.  */
2420
2421 static boolean
2422 mips_elf64_slurp_reloc_table (abfd, asect, symbols, dynamic)
2423      bfd *abfd;
2424      asection *asect;
2425      asymbol **symbols;
2426      boolean dynamic;
2427 {
2428   bfd_size_type amt;
2429   struct bfd_elf_section_data * const d = elf_section_data (asect);
2430
2431   if (dynamic)
2432     {
2433       bfd_set_error (bfd_error_invalid_operation);
2434       return false;
2435     }
2436
2437   if (asect->relocation != NULL
2438       || (asect->flags & SEC_RELOC) == 0
2439       || asect->reloc_count == 0)
2440     return true;
2441
2442   /* Allocate space for 3 arelent structures for each Rel structure.  */
2443   amt = asect->reloc_count;
2444   amt *= 3 * sizeof (arelent);
2445   asect->relocation = (arelent *) bfd_alloc (abfd, amt);
2446   if (asect->relocation == NULL)
2447     return false;
2448
2449   /* The slurp_one_reloc_table routine increments reloc_count.  */
2450   asect->reloc_count = 0;
2451
2452   if (! mips_elf64_slurp_one_reloc_table (abfd, asect, symbols, &d->rel_hdr))
2453     return false;
2454   if (d->rel_hdr2 != NULL)
2455     {
2456       if (! mips_elf64_slurp_one_reloc_table (abfd, asect, symbols,
2457                                               d->rel_hdr2))
2458         return false;
2459     }
2460
2461   return true;
2462 }
2463
2464 /* Write out the relocations.  */
2465
2466 static void
2467 mips_elf64_write_relocs (abfd, sec, data)
2468      bfd *abfd;
2469      asection *sec;
2470      PTR data;
2471 {
2472   boolean *failedp = (boolean *) data;
2473   int count;
2474   Elf_Internal_Shdr *rel_hdr;
2475   unsigned int idx;
2476
2477   /* If we have already failed, don't do anything.  */
2478   if (*failedp)
2479     return;
2480
2481   if ((sec->flags & SEC_RELOC) == 0)
2482     return;
2483
2484   /* The linker backend writes the relocs out itself, and sets the
2485      reloc_count field to zero to inhibit writing them here.  Also,
2486      sometimes the SEC_RELOC flag gets set even when there aren't any
2487      relocs.  */
2488   if (sec->reloc_count == 0)
2489     return;
2490
2491   /* We can combine up to three relocs that refer to the same address
2492      if the latter relocs have no associated symbol.  */
2493   count = 0;
2494   for (idx = 0; idx < sec->reloc_count; idx++)
2495     {
2496       bfd_vma addr;
2497       unsigned int i;
2498
2499       ++count;
2500
2501       addr = sec->orelocation[idx]->address;
2502       for (i = 0; i < 2; i++)
2503         {
2504           arelent *r;
2505
2506           if (idx + 1 >= sec->reloc_count)
2507             break;
2508           r = sec->orelocation[idx + 1];
2509           if (r->address != addr
2510               || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2511               || (*r->sym_ptr_ptr)->value != 0)
2512             break;
2513
2514           /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */
2515
2516           ++idx;
2517         }
2518     }
2519
2520   rel_hdr = &elf_section_data (sec)->rel_hdr;
2521
2522   /* Do the actual relocation.  */
2523
2524   if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rel))
2525     mips_elf64_write_rel (abfd, sec, rel_hdr, &count, data);
2526   else if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rela))
2527     mips_elf64_write_rela (abfd, sec, rel_hdr, &count, data);
2528   else
2529     BFD_ASSERT (0);
2530 }
2531
2532 static void
2533 mips_elf64_write_rel (abfd, sec, rel_hdr, count, data)
2534      bfd *abfd;
2535      asection *sec;
2536      Elf_Internal_Shdr *rel_hdr;
2537      int *count;
2538      PTR data;
2539 {
2540   boolean *failedp = (boolean *) data;
2541   Elf64_Mips_External_Rel *ext_rel;
2542   unsigned int idx;
2543   asymbol *last_sym = 0;
2544   int last_sym_idx = 0;
2545
2546   rel_hdr->sh_size = (bfd_vma)(rel_hdr->sh_entsize * *count);
2547   rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
2548   if (rel_hdr->contents == NULL)
2549     {
2550       *failedp = true;
2551       return;
2552     }
2553
2554   ext_rel = (Elf64_Mips_External_Rel *) rel_hdr->contents;
2555   for (idx = 0; idx < sec->reloc_count; idx++, ext_rel++)
2556     {
2557       arelent *ptr;
2558       Elf64_Mips_Internal_Rel int_rel;
2559       asymbol *sym;
2560       int n;
2561       unsigned int i;
2562
2563       ptr = sec->orelocation[idx];
2564
2565       /* The address of an ELF reloc is section relative for an object
2566          file, and absolute for an executable file or shared library.
2567          The address of a BFD reloc is always section relative.  */
2568       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2569         int_rel.r_offset = ptr->address;
2570       else
2571         int_rel.r_offset = ptr->address + sec->vma;
2572
2573       sym = *ptr->sym_ptr_ptr;
2574       if (sym == last_sym)
2575         n = last_sym_idx;
2576       else
2577         {
2578           last_sym = sym;
2579           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
2580           if (n < 0)
2581             {
2582               *failedp = true;
2583               return;
2584             }
2585           last_sym_idx = n;
2586         }
2587
2588       int_rel.r_sym = n;
2589       int_rel.r_ssym = RSS_UNDEF;
2590
2591       if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
2592           && ! _bfd_elf_validate_reloc (abfd, ptr))
2593         {
2594           *failedp = true;
2595           return;
2596         }
2597
2598       int_rel.r_type = ptr->howto->type;
2599       int_rel.r_type2 = (int) R_MIPS_NONE;
2600       int_rel.r_type3 = (int) R_MIPS_NONE;
2601
2602       for (i = 0; i < 2; i++)
2603         {
2604           arelent *r;
2605
2606           if (idx + 1 >= sec->reloc_count)
2607             break;
2608           r = sec->orelocation[idx + 1];
2609           if (r->address != ptr->address
2610               || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2611               || (*r->sym_ptr_ptr)->value != 0)
2612             break;
2613
2614           /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */
2615
2616           if (i == 0)
2617             int_rel.r_type2 = r->howto->type;
2618           else
2619             int_rel.r_type3 = r->howto->type;
2620
2621           ++idx;
2622         }
2623
2624       mips_elf64_swap_reloc_out (abfd, &int_rel, ext_rel);
2625     }
2626
2627   BFD_ASSERT (ext_rel - (Elf64_Mips_External_Rel *) rel_hdr->contents
2628               == *count);
2629 }
2630
2631 static void
2632 mips_elf64_write_rela (abfd, sec, rela_hdr, count, data)
2633      bfd *abfd;
2634      asection *sec;
2635      Elf_Internal_Shdr *rela_hdr;
2636      int *count;
2637      PTR data;
2638 {
2639   boolean *failedp = (boolean *) data;
2640   Elf64_Mips_External_Rela *ext_rela;
2641   unsigned int idx;
2642   asymbol *last_sym = 0;
2643   int last_sym_idx = 0;
2644
2645   rela_hdr->sh_size = (bfd_vma)(rela_hdr->sh_entsize * *count);
2646   rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
2647   if (rela_hdr->contents == NULL)
2648     {
2649       *failedp = true;
2650       return;
2651     }
2652
2653   ext_rela = (Elf64_Mips_External_Rela *) rela_hdr->contents;
2654   for (idx = 0; idx < sec->reloc_count; idx++, ext_rela++)
2655     {
2656       arelent *ptr;
2657       Elf64_Mips_Internal_Rela int_rela;
2658       asymbol *sym;
2659       int n;
2660       unsigned int i;
2661
2662       ptr = sec->orelocation[idx];
2663
2664       /* The address of an ELF reloc is section relative for an object
2665          file, and absolute for an executable file or shared library.
2666          The address of a BFD reloc is always section relative.  */
2667       if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2668         int_rela.r_offset = ptr->address;
2669       else
2670         int_rela.r_offset = ptr->address + sec->vma;
2671
2672       sym = *ptr->sym_ptr_ptr;
2673       if (sym == last_sym)
2674         n = last_sym_idx;
2675       else
2676         {
2677           last_sym = sym;
2678           n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
2679           if (n < 0)
2680             {
2681               *failedp = true;
2682               return;
2683             }
2684           last_sym_idx = n;
2685         }
2686
2687       int_rela.r_sym = n;
2688       int_rela.r_addend = ptr->addend;
2689       int_rela.r_ssym = RSS_UNDEF;
2690
2691       if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
2692           && ! _bfd_elf_validate_reloc (abfd, ptr))
2693         {
2694           *failedp = true;
2695           return;
2696         }
2697
2698       int_rela.r_type = ptr->howto->type;
2699       int_rela.r_type2 = (int) R_MIPS_NONE;
2700       int_rela.r_type3 = (int) R_MIPS_NONE;
2701
2702       for (i = 0; i < 2; i++)
2703         {
2704           arelent *r;
2705
2706           if (idx + 1 >= sec->reloc_count)
2707             break;
2708           r = sec->orelocation[idx + 1];
2709           if (r->address != ptr->address
2710               || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2711               || (*r->sym_ptr_ptr)->value != 0)
2712             break;
2713
2714           /* We can merge the reloc at IDX + 1 with the reloc at IDX.  */
2715
2716           if (i == 0)
2717             int_rela.r_type2 = r->howto->type;
2718           else
2719             int_rela.r_type3 = r->howto->type;
2720
2721           ++idx;
2722         }
2723
2724       mips_elf64_swap_reloca_out (abfd, &int_rela, ext_rela);
2725     }
2726
2727   BFD_ASSERT (ext_rela - (Elf64_Mips_External_Rela *) rela_hdr->contents
2728               == *count);
2729 }
2730 \f
2731 /* This structure is used to hold .got information when linking.  It
2732    is stored in the tdata field of the bfd_elf_section_data structure.  */
2733
2734 struct mips_elf64_got_info
2735 {
2736   /* The global symbol in the GOT with the lowest index in the dynamic
2737      symbol table.  */
2738   struct elf_link_hash_entry *global_gotsym;
2739   /* The number of global .got entries.  */
2740   unsigned int global_gotno;
2741   /* The number of local .got entries.  */
2742   unsigned int local_gotno;
2743   /* The number of local .got entries we have used.  */
2744   unsigned int assigned_gotno;
2745 };
2746
2747 /* The MIPS ELF64 linker needs additional information for each symbol in
2748    the global hash table.  */
2749
2750 struct mips_elf64_link_hash_entry
2751 {
2752   struct elf_link_hash_entry root;
2753
2754   /* External symbol information.  */
2755   EXTR esym;
2756
2757   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
2758      this symbol.  */
2759   unsigned int possibly_dynamic_relocs;
2760
2761   /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
2762      a readonly section.  */
2763   boolean readonly_reloc;
2764
2765   /* The index of the first dynamic relocation (in the .rel.dyn
2766      section) against this symbol.  */
2767   unsigned int min_dyn_reloc_index;
2768
2769   /* We must not create a stub for a symbol that has relocations
2770      related to taking the function's address, i.e. any but
2771      R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
2772      p. 4-20.  */
2773   boolean no_fn_stub;
2774
2775   /* If there is a stub that 32 bit functions should use to call this
2776      16 bit function, this points to the section containing the stub.  */
2777   asection *fn_stub;
2778
2779   /* Whether we need the fn_stub; this is set if this symbol appears
2780      in any relocs other than a 16 bit call.  */
2781   boolean need_fn_stub;
2782
2783   /* If there is a stub that 16 bit functions should use to call this
2784      32 bit function, this points to the section containing the stub.  */
2785   asection *call_stub;
2786
2787   /* This is like the call_stub field, but it is used if the function
2788      being called returns a floating point value.  */
2789   asection *call_fp_stub;
2790 };
2791 \f
2792   /* The mips16 compiler uses a couple of special sections to handle
2793      floating point arguments.
2794
2795      Section names that look like .mips16.fn.FNNAME contain stubs that
2796      copy floating point arguments from the fp regs to the gp regs and
2797      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
2798      call should be redirected to the stub instead.  If no 32 bit
2799      function calls FNNAME, the stub should be discarded.  We need to
2800      consider any reference to the function, not just a call, because
2801      if the address of the function is taken we will need the stub,
2802      since the address might be passed to a 32 bit function.
2803
2804      Section names that look like .mips16.call.FNNAME contain stubs
2805      that copy floating point arguments from the gp regs to the fp
2806      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
2807      then any 16 bit function that calls FNNAME should be redirected
2808      to the stub instead.  If FNNAME is not a 32 bit function, the
2809      stub should be discarded.
2810
2811      .mips16.call.fp.FNNAME sections are similar, but contain stubs
2812      which call FNNAME and then copy the return value from the fp regs
2813      to the gp regs.  These stubs store the return value in $18 while
2814      calling FNNAME; any function which might call one of these stubs
2815      must arrange to save $18 around the call.  (This case is not
2816      needed for 32 bit functions that call 16 bit functions, because
2817      16 bit functions always return floating point values in both
2818      $f0/$f1 and $2/$3.)
2819
2820      Note that in all cases FNNAME might be defined statically.
2821      Therefore, FNNAME is not used literally.  Instead, the relocation
2822      information will indicate which symbol the section is for.
2823
2824      We record any stubs that we find in the symbol table.  */
2825
2826 #define FN_STUB ".mips16.fn."
2827 #define CALL_STUB ".mips16.call."
2828 #define CALL_FP_STUB ".mips16.call.fp."
2829
2830 /* MIPS ELF64 linker hash table.  */
2831
2832 struct mips_elf64_link_hash_table
2833 {
2834   struct elf_link_hash_table root;
2835   /* This is set if we see any mips16 stub sections.  */
2836   boolean mips16_stubs_seen;
2837 };
2838
2839 /* Look up an entry in a MIPS ELF64 linker hash table.  */
2840
2841 #define mips_elf64_link_hash_lookup(table, string, create, copy, follow) \
2842   ((struct mips_elf64_link_hash_entry *)                                \
2843    elf_link_hash_lookup (&(table)->root, (string), (create),            \
2844                          (copy), (follow)))
2845
2846 /* Traverse a MIPS ELF linker hash table.  */
2847
2848 #define mips_elf64_link_hash_traverse(table, func, info)                \
2849   (elf_link_hash_traverse                                               \
2850    (&(table)->root,                                                     \
2851     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
2852     (info)))
2853
2854 /* Get the MIPS ELF64 linker hash table from a link_info structure.  */
2855
2856 #define mips_elf64_hash_table(p) \
2857   ((struct mips_elf64_link_hash_table *) ((p)->hash))
2858
2859 /* Create an entry in a MIPS ELF64 linker hash table.  */
2860
2861 static struct bfd_hash_entry *
2862 mips_elf64_link_hash_newfunc (entry, table, string)
2863      struct bfd_hash_entry *entry;
2864      struct bfd_hash_table *table;
2865      const char *string;
2866 {
2867   struct mips_elf64_link_hash_entry *ret =
2868     (struct mips_elf64_link_hash_entry *) entry;
2869
2870   /* Allocate the structure if it has not already been allocated by a
2871      subclass.  */
2872   if (ret == (struct mips_elf64_link_hash_entry *) NULL)
2873     ret = ((struct mips_elf64_link_hash_entry *)
2874            bfd_hash_allocate (table,
2875                               sizeof (struct mips_elf64_link_hash_entry)));
2876   if (ret == (struct mips_elf64_link_hash_entry *) NULL)
2877     return (struct bfd_hash_entry *) ret;
2878
2879   /* Call the allocation method of the superclass.  */
2880   ret = ((struct mips_elf64_link_hash_entry *)
2881          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2882                                      table, string));
2883   if (ret != (struct mips_elf64_link_hash_entry *) NULL)
2884     {
2885       /* Set local fields.  */
2886       memset (&ret->esym, 0, sizeof (EXTR));
2887       /* We use -2 as a marker to indicate that the information has
2888          not been set.  -1 means there is no associated ifd.  */
2889       ret->esym.ifd = -2;
2890       ret->possibly_dynamic_relocs = 0;
2891       ret->readonly_reloc = false;
2892       ret->min_dyn_reloc_index = 0;
2893       ret->no_fn_stub = false;
2894       ret->fn_stub = NULL;
2895       ret->need_fn_stub = false;
2896       ret->call_stub = NULL;
2897       ret->call_fp_stub = NULL;
2898     }
2899
2900   return (struct bfd_hash_entry *) ret;
2901 }
2902
2903 /* Create a MIPS ELF64 linker hash table.  */
2904
2905 struct bfd_link_hash_table *
2906 mips_elf64_link_hash_table_create (abfd)
2907      bfd *abfd;
2908 {
2909   struct mips_elf64_link_hash_table *ret;
2910
2911   ret = ((struct mips_elf64_link_hash_table *)
2912          bfd_alloc (abfd, sizeof (struct mips_elf64_link_hash_table)));
2913   if (ret == (struct mips_elf64_link_hash_table *) NULL)
2914     return NULL;
2915
2916   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2917                                        mips_elf64_link_hash_newfunc))
2918     {
2919       bfd_release (abfd, ret);
2920       return NULL;
2921     }
2922
2923   ret->mips16_stubs_seen = false;
2924
2925   return &ret->root.root;
2926 }
2927 \f
2928 /* Returns the offset for the entry at the INDEXth position
2929    in the GOT.  */
2930
2931 static bfd_vma
2932 mips_elf64_got_offset_from_index (dynobj, output_bfd, index)
2933      bfd *dynobj;
2934      bfd *output_bfd;
2935      bfd_vma index;
2936 {
2937   asection *sgot;
2938   bfd_vma gp;
2939
2940   sgot = bfd_get_section_by_name (dynobj, ".got");
2941   gp = _bfd_get_gp_value (output_bfd);
2942   return (sgot->output_section->vma + sgot->output_offset + index -
2943           gp);
2944 }
2945
2946 /* Returns the GOT information associated with the link indicated by
2947    INFO.  If SGOTP is non-NULL, it is filled in with the GOT
2948    section.  */
2949
2950 static struct mips_elf64_got_info *
2951 _mips_elf64_got_info (abfd, sgotp)
2952      bfd *abfd;
2953      asection **sgotp;
2954 {
2955   asection *sgot;
2956   struct mips_elf64_got_info *g;
2957
2958   sgot = bfd_get_section_by_name (abfd, ".got");
2959   BFD_ASSERT (sgot != NULL);
2960   BFD_ASSERT (elf_section_data (sgot) != NULL);
2961   g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
2962   BFD_ASSERT (g != NULL);
2963
2964   if (sgotp)
2965     *sgotp = sgot;
2966   return g;
2967 }
2968
2969 /* Sign-extend VALUE, which has the indicated number of BITS.  */
2970
2971 static bfd_vma
2972 mips_elf64_sign_extend (value, bits)
2973      bfd_vma value;
2974      int bits;
2975 {
2976   if (value & ((bfd_vma)1 << (bits - 1)))
2977     /* VALUE is negative.  */
2978     value |= ((bfd_vma) - 1) << bits;
2979
2980   return value;
2981 }
2982
2983 /* Return non-zero if the indicated VALUE has overflowed the maximum
2984    range expressable by a signed number with the indicated number of
2985    BITS.  */
2986
2987 static boolean
2988 mips_elf64_overflow_p (value, bits)
2989      bfd_vma value;
2990      int bits;
2991 {
2992   bfd_signed_vma svalue = (bfd_signed_vma) value;
2993
2994   if (svalue > (1 << (bits - 1)) - 1)
2995     /* The value is too big.  */
2996     return true;
2997   else if (svalue < -(1 << (bits - 1)))
2998     /* The value is too small.  */
2999     return true;
3000
3001   /* All is well.  */
3002   return false;
3003 }
3004 \f
3005 /* Returns the GOT index for the global symbol indicated by H.  */
3006
3007 static bfd_vma
3008 mips_elf64_global_got_index (abfd, h)
3009      bfd *abfd;
3010      struct elf_link_hash_entry *h;
3011 {
3012   bfd_vma index;
3013   asection *sgot;
3014   struct mips_elf64_got_info *g;
3015
3016   g = _mips_elf64_got_info (abfd, &sgot);
3017
3018   /* Once we determine the global GOT entry with the lowest dynamic
3019      symbol table index, we must put all dynamic symbols with greater
3020      indices into the GOT.  That makes it easy to calculate the GOT
3021      offset.  */
3022   BFD_ASSERT (h->dynindx >= g->global_gotsym->dynindx);
3023   index = ((h->dynindx - g->global_gotsym->dynindx + g->local_gotno)
3024            * (get_elf_backend_data (abfd)->s->arch_size / 8));
3025   BFD_ASSERT (index < sgot->_raw_size);
3026
3027   return index;
3028 }
3029
3030 struct mips_elf64_hash_sort_data
3031 {
3032   /* The symbol in the global GOT with the lowest dynamic symbol table
3033      index.  */
3034   struct elf_link_hash_entry *low;
3035   /* The least dynamic symbol table index corresponding to a symbol
3036      with a GOT entry.  */
3037   long min_got_dynindx;
3038   /* The greatest dynamic symbol table index not corresponding to a
3039      symbol without a GOT entry.  */
3040   long max_non_got_dynindx;
3041 };
3042
3043 /* If H needs a GOT entry, assign it the highest available dynamic
3044    index.  Otherwise, assign it the lowest available dynamic
3045    index.  */
3046
3047 static boolean
3048 mips_elf64_sort_hash_table_f (h, data)
3049      struct mips_elf64_link_hash_entry *h;
3050      PTR data;
3051 {
3052   struct mips_elf64_hash_sort_data *hsd
3053     = (struct mips_elf64_hash_sort_data *) data;
3054
3055   /* Symbols without dynamic symbol table entries aren't interesting
3056      at all.  */
3057   if (h->root.dynindx == -1)
3058     return true;
3059
3060   if (h->root.got.offset != 1)
3061     h->root.dynindx = hsd->max_non_got_dynindx++;
3062   else
3063     {
3064       h->root.dynindx = --hsd->min_got_dynindx;
3065       hsd->low = (struct elf_link_hash_entry *) h;
3066     }
3067
3068   return true;
3069 }
3070
3071 /* Sort the dynamic symbol table so that symbols that need GOT entries
3072    appear towards the end.  This reduces the amount of GOT space
3073    required.  MAX_LOCAL is used to set the number of local symbols
3074    known to be in the dynamic symbol table.  During
3075    mips_elf64_size_dynamic_sections, this value is 1.  Afterward, the
3076    section symbols are added and the count is higher.  */
3077
3078 static boolean
3079 mips_elf64_sort_hash_table (info, max_local)
3080      struct bfd_link_info *info;
3081      unsigned long max_local;
3082 {
3083   struct mips_elf64_hash_sort_data hsd;
3084   struct mips_elf64_got_info *g;
3085   bfd *dynobj;
3086
3087   dynobj = elf_hash_table (info)->dynobj;
3088
3089   hsd.low = NULL;
3090   hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount;
3091   hsd.max_non_got_dynindx = max_local;
3092   mips_elf64_link_hash_traverse (((struct mips_elf64_link_hash_table *)
3093                                 elf_hash_table (info)),
3094                                mips_elf64_sort_hash_table_f,
3095                                &hsd);
3096
3097   /* There shoud have been enough room in the symbol table to
3098      accomodate both the GOT and non-GOT symbols.  */
3099   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3100
3101   /* Now we know which dynamic symbol has the lowest dynamic symbol
3102      table index in the GOT.  */
3103   g = _mips_elf64_got_info (dynobj, NULL);
3104   g->global_gotsym = hsd.low;
3105
3106   return true;
3107 }
3108 \f
3109 #if 0
3110 /* Swap in an MSYM entry.  */
3111
3112 static void
3113 mips_elf64_swap_msym_in (abfd, ex, in)
3114      bfd *abfd;
3115      const Elf32_External_Msym *ex;
3116      Elf32_Internal_Msym *in;
3117 {
3118   in->ms_hash_value = H_GET_32 (abfd, ex->ms_hash_value);
3119   in->ms_info = H_GET_32 (abfd, ex->ms_info);
3120 }
3121 #endif
3122 /* Swap out an MSYM entry.  */
3123
3124 static void
3125 mips_elf64_swap_msym_out (abfd, in, ex)
3126      bfd *abfd;
3127      const Elf32_Internal_Msym *in;
3128      Elf32_External_Msym *ex;
3129 {
3130   H_PUT_32 (abfd, in->ms_hash_value, ex->ms_hash_value);
3131   H_PUT_32 (abfd, in->ms_info, ex->ms_info);
3132 }
3133 \f
3134 /* Create a local GOT entry for VALUE.  Return the index of the entry,
3135    or -1 if it could not be created.  */
3136
3137 static bfd_vma
3138 mips_elf64_create_local_got_entry (abfd, g, sgot, value)
3139      bfd *abfd;
3140      struct mips_elf64_got_info *g;
3141      asection *sgot;
3142      bfd_vma value;
3143 {
3144   CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3145
3146   if (g->assigned_gotno >= g->local_gotno)
3147     {
3148       /* We didn't allocate enough space in the GOT.  */
3149       (*_bfd_error_handler)
3150         (_("not enough GOT space for local GOT entries"));
3151       bfd_set_error (bfd_error_bad_value);
3152       return (bfd_vma) -1;
3153     }
3154
3155   bfd_put_64 (abfd, value, (sgot->contents + got_size * g->assigned_gotno));
3156   return got_size * g->assigned_gotno++;
3157 }
3158
3159 /* Returns the GOT offset at which the indicated address can be found.
3160    If there is not yet a GOT entry for this value, create one.  Returns
3161    -1 if no satisfactory GOT offset can be found.  */
3162
3163 static bfd_vma
3164 mips_elf64_local_got_index (abfd, info, value)
3165      bfd *abfd;
3166      struct bfd_link_info *info;
3167      bfd_vma value;
3168 {
3169   CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3170   asection *sgot;
3171   struct mips_elf64_got_info *g;
3172   bfd_byte *entry;
3173
3174   g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3175
3176   /* Look to see if we already have an appropriate entry.  */
3177   for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3178        entry != sgot->contents + got_size * g->assigned_gotno;
3179        entry += got_size)
3180     {
3181       bfd_vma address = bfd_get_64 (abfd, entry);
3182       if (address == value)
3183         return entry - sgot->contents;
3184     }
3185
3186   return mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3187 }
3188
3189 /* Find a GOT entry that is within 32KB of the VALUE.  These entries
3190    are supposed to be placed at small offsets in the GOT, i.e.,
3191    within 32KB of GP.  Return the index into the GOT for this page,
3192    and store the offset from this entry to the desired address in
3193    OFFSETP, if it is non-NULL.  */
3194
3195 static bfd_vma
3196 mips_elf64_got_page (abfd, info, value, offsetp)
3197      bfd *abfd;
3198      struct bfd_link_info *info;
3199      bfd_vma value;
3200      bfd_vma *offsetp;
3201 {
3202   CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3203   asection *sgot;
3204   struct mips_elf64_got_info *g;
3205   bfd_byte *entry;
3206   bfd_byte *last_entry;
3207   bfd_vma index = 0;
3208   bfd_vma address;
3209
3210   g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3211
3212   /* Look to see if we aleady have an appropriate entry.  */
3213   last_entry = sgot->contents + got_size * g->assigned_gotno;
3214   for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3215        entry != last_entry;
3216        entry += got_size)
3217     {
3218       address = bfd_get_64 (abfd, entry);
3219
3220       if (!mips_elf64_overflow_p (value - address, 16))
3221         {
3222           /* This entry will serve as the page pointer.  We can add a
3223              16-bit number to it to get the actual address.  */
3224           index = entry - sgot->contents;
3225           break;
3226         }
3227     }
3228
3229   /* If we didn't have an appropriate entry, we create one now.  */
3230   if (entry == last_entry)
3231     index = mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3232
3233   if (offsetp)
3234     {
3235       address = bfd_get_64 (abfd, entry);
3236       *offsetp = value - address;
3237     }
3238
3239   return index;
3240 }
3241
3242 /* Find a GOT entry whose higher-order 16 bits are the same as those
3243    for value.  Return the index into the GOT for this entry.  */
3244
3245 static bfd_vma
3246 mips_elf64_got16_entry (abfd, info, value, external)
3247      bfd *abfd;
3248      struct bfd_link_info *info;
3249      bfd_vma value;
3250      boolean external;
3251 {
3252   CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3253   asection *sgot;
3254   struct mips_elf64_got_info *g;
3255   bfd_byte *entry;
3256   bfd_byte *last_entry;
3257   bfd_vma index = 0;
3258   bfd_vma address;
3259
3260   if (! external)
3261     {
3262       /* Although the ABI says that it is "the high-order 16 bits" that we
3263          want, it is really the %high value.  The complete value is
3264          calculated with a `addiu' of a LO16 relocation, just as with a
3265          HI16/LO16 pair.  */
3266       value = mips_elf64_high (value) << 16;
3267     }
3268
3269   g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3270
3271   /* Look to see if we already have an appropriate entry.  */
3272   last_entry = sgot->contents + got_size * g->assigned_gotno;
3273   for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3274        entry != last_entry;
3275        entry += got_size)
3276     {
3277       address = bfd_get_64 (abfd, entry);
3278       if (address == value)
3279         {
3280           /* This entry has the right high-order 16 bits, and the low-order
3281              16 bits are set to zero.  */
3282           index = entry - sgot->contents;
3283           break;
3284         }
3285     }
3286
3287   /* If we didn't have an appropriate entry, we create one now.  */
3288   if (entry == last_entry)
3289     index = mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3290
3291   return index;
3292 }
3293 \f
3294 /* Return whether a relocation is against a local symbol.  */
3295
3296 static boolean
3297 mips_elf64_local_relocation_p (input_bfd, relocation, local_sections,
3298                              check_forced)
3299      bfd *input_bfd;
3300      const Elf_Internal_Rela *relocation;
3301      asection **local_sections;
3302      boolean check_forced;
3303 {
3304   unsigned long r_symndx;
3305   Elf_Internal_Shdr *symtab_hdr;
3306   struct mips_elf64_link_hash_entry* h;
3307   size_t extsymoff;
3308
3309   r_symndx = ELF64_R_SYM (relocation->r_info);
3310   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3311   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
3312
3313   if (r_symndx < extsymoff)
3314     return true;
3315   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
3316     return true;
3317
3318   if (check_forced)
3319     {
3320        /* Look up the hash table to check whether the symbol
3321          was forced local.  */
3322        h = (struct mips_elf64_link_hash_entry *)
3323           elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
3324        /* Find the real hash-table entry for this symbol.  */
3325        while (h->root.root.type == bfd_link_hash_indirect
3326              || h->root.root.type == bfd_link_hash_warning)
3327          h = (struct mips_elf64_link_hash_entry *) h->root.root.u.i.link;
3328        if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
3329          return true;
3330     }
3331
3332   return false;
3333 }
3334 \f
3335 /* Returns the first relocation of type r_type found, beginning with
3336    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
3337
3338 static const Elf_Internal_Rela *
3339 mips_elf64_next_relocation (r_type, relocation, relend)
3340      unsigned int r_type;
3341      const Elf_Internal_Rela *relocation;
3342      const Elf_Internal_Rela *relend;
3343 {
3344   /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
3345      immediately following.  However, for the IRIX6 ABI, the next
3346      relocation may be a composed relocation consisting of several
3347      relocations for the same address.  In that case, the R_MIPS_LO16
3348      relocation may occur as one of these.  We permit a similar
3349      extension in general, as that is useful for GCC.  */
3350   while (relocation < relend)
3351     {
3352       if (ELF64_MIPS_R_TYPE (relocation->r_info) == r_type)
3353         return relocation;
3354
3355       ++relocation;
3356     }
3357
3358   /* We didn't find it.  */
3359   bfd_set_error (bfd_error_bad_value);
3360   return NULL;
3361 }
3362
3363 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
3364    is the original relocation, which is now being transformed into a
3365    dynamic relocation.  The ADDENDP is adjusted if necessary; the
3366    caller should store the result in place of the original addend.  */
3367
3368 static boolean
3369 mips_elf64_create_dynamic_relocation (output_bfd, info, rel, h, sec,
3370                                     symbol, addendp, input_section)
3371      bfd *output_bfd;
3372      struct bfd_link_info *info;
3373      const Elf_Internal_Rela *rel;
3374      struct mips_elf64_link_hash_entry *h;
3375      asection *sec;
3376      bfd_vma symbol;
3377      bfd_vma *addendp;
3378      asection *input_section;
3379 {
3380   Elf_Internal_Rel outrel[3];
3381   boolean skip;
3382   asection *sreloc;
3383   bfd *dynobj;
3384   int r_type;
3385
3386   r_type = ELF64_MIPS_R_TYPE (rel->r_info);
3387   dynobj = elf_hash_table (info)->dynobj;
3388   sreloc = bfd_get_section_by_name (dynobj, ".rel.dyn");
3389   BFD_ASSERT (sreloc != NULL);
3390   BFD_ASSERT (sreloc->contents != NULL);
3391   BFD_ASSERT ((sreloc->reloc_count
3392                * get_elf_backend_data (output_bfd)->s->sizeof_rel)
3393               < sreloc->_raw_size);
3394
3395   skip = false;
3396   outrel[0].r_offset = _bfd_elf_section_offset (output_bfd, info,
3397                                                 input_section,
3398                                                 rel[0].r_offset);
3399   /* FIXME: For -2 runtime relocation needs to be skipped, but
3400      properly resolved statically and installed.  */
3401   BFD_ASSERT (outrel[0].r_offset != (bfd_vma) -2);
3402
3403   /* We begin by assuming that the offset for the dynamic relocation
3404      is the same as for the original relocation.  We'll adjust this
3405      later to reflect the correct output offsets.  */
3406   if (elf_section_data (input_section)->sec_info_type != ELF_INFO_TYPE_STABS)
3407     {
3408       outrel[1].r_offset = rel[1].r_offset;
3409       outrel[2].r_offset = rel[2].r_offset;
3410     }
3411   else
3412     {
3413       /* Except that in a stab section things are more complex.
3414          Because we compress stab information, the offset given in the
3415          relocation may not be the one we want; we must let the stabs
3416          machinery tell us the offset.  */
3417       outrel[1].r_offset = outrel[0].r_offset;
3418       outrel[2].r_offset = outrel[0].r_offset;
3419       /* If we didn't need the relocation at all, this value will be
3420          -1.  */
3421       if (outrel[0].r_offset == (bfd_vma) -1)
3422         skip = true;
3423     }
3424
3425   /* If we've decided to skip this relocation, just output an empty
3426      record.  Note that R_MIPS_NONE == 0, so that this call to memset
3427      is a way of setting R_TYPE to R_MIPS_NONE.  */
3428   if (skip)
3429     memset (outrel, 0, sizeof (Elf_Internal_Rel) * 3);
3430   else
3431     {
3432       long indx;
3433       bfd_vma section_offset;
3434
3435       /* We must now calculate the dynamic symbol table index to use
3436          in the relocation.  */
3437       if (h != NULL
3438           && (! info->symbolic || (h->root.elf_link_hash_flags
3439                                    & ELF_LINK_HASH_DEF_REGULAR) == 0))
3440         {
3441           indx = h->root.dynindx;
3442           /* h->root.dynindx may be -1 if this symbol was marked to
3443              become local.  */
3444           if (indx == -1)
3445                 indx = 0;
3446         }
3447       else
3448         {
3449           if (sec != NULL && bfd_is_abs_section (sec))
3450             indx = 0;
3451           else if (sec == NULL || sec->owner == NULL)
3452             {
3453               bfd_set_error (bfd_error_bad_value);
3454               return false;
3455             }
3456           else
3457             {
3458               indx = elf_section_data (sec->output_section)->dynindx;
3459               if (indx == 0)
3460                 abort ();
3461             }
3462
3463           /* Figure out how far the target of the relocation is from
3464              the beginning of its section.  */
3465           section_offset = symbol - sec->output_section->vma;
3466           /* The relocation we're building is section-relative.
3467              Therefore, the original addend must be adjusted by the
3468              section offset.  */
3469           *addendp += section_offset;
3470           /* Now, the relocation is just against the section.  */
3471           symbol = sec->output_section->vma;
3472         }
3473
3474       /* If the relocation was previously an absolute relocation and
3475          this symbol will not be referred to by the relocation, we must
3476          adjust it by the value we give it in the dynamic symbol table.
3477          Otherwise leave the job up to the dynamic linker.  */
3478       if (!indx && r_type != R_MIPS_REL32)
3479         *addendp += symbol;
3480
3481       /* The relocation is always an REL32 relocation because we don't
3482          know where the shared library will wind up at load-time.  */
3483       outrel[0].r_info = ELF64_R_INFO (indx, R_MIPS_REL32);
3484
3485       /* Adjust the output offset of the relocation to reference the
3486          correct location in the output file.  */
3487       outrel[0].r_offset += (input_section->output_section->vma
3488                              + input_section->output_offset);
3489       outrel[1].r_offset += (input_section->output_section->vma
3490                              + input_section->output_offset);
3491       outrel[2].r_offset += (input_section->output_section->vma
3492                              + input_section->output_offset);
3493     }
3494
3495   /* Put the relocation back out.  */
3496   mips_elf64_be_swap_reloc_out (output_bfd, outrel,
3497                                 (sreloc->contents
3498                                  + sreloc->reloc_count
3499                                    * sizeof (Elf64_Mips_External_Rel)));
3500
3501   /* Record the index of the first relocation referencing H.  This
3502      information is later emitted in the .msym section.  */
3503   if (h != NULL
3504       && (h->min_dyn_reloc_index == 0
3505           || sreloc->reloc_count < h->min_dyn_reloc_index))
3506     h->min_dyn_reloc_index = sreloc->reloc_count;
3507
3508   /* We've now added another relocation.  */
3509   ++sreloc->reloc_count;
3510
3511   /* Make sure the output section is writable.  The dynamic linker
3512      will be writing to it.  */
3513   elf_section_data (input_section->output_section)->this_hdr.sh_flags
3514     |= SHF_WRITE;
3515
3516   return true;
3517 }
3518
3519 /* Calculate the value produced by the RELOCATION (which comes from
3520    the INPUT_BFD).  The ADDEND is the addend to use for this
3521    RELOCATION; RELOCATION->R_ADDEND is ignored.
3522
3523    The result of the relocation calculation is stored in VALUEP.
3524    REQUIRE_JALXP indicates whether or not the opcode used with this
3525    relocation must be JALX.
3526
3527    This function returns bfd_reloc_continue if the caller need take no
3528    further action regarding this relocation, bfd_reloc_notsupported if
3529    something goes dramatically wrong, bfd_reloc_overflow if an
3530    overflow occurs, and bfd_reloc_ok to indicate success.  */
3531
3532 static bfd_reloc_status_type
3533 mips_elf64_calculate_relocation (abfd, input_bfd, input_section, info,
3534                                  relocation, addend, howto, local_syms,
3535                                  local_sections, valuep, namep, require_jalxp)
3536      bfd *abfd;
3537      bfd *input_bfd;
3538      asection *input_section;
3539      struct bfd_link_info *info;
3540      const Elf_Internal_Rela *relocation;
3541      bfd_vma addend;
3542      reloc_howto_type *howto;
3543      Elf_Internal_Sym *local_syms;
3544      asection **local_sections;
3545      bfd_vma *valuep;
3546      const char **namep;
3547      boolean *require_jalxp;
3548 {
3549   /* The eventual value we will return.  */
3550   bfd_vma value;
3551   /* The address of the symbol against which the relocation is
3552      occurring.  */
3553   bfd_vma symbol = 0;
3554   /* The final GP value to be used for the relocatable, executable, or
3555      shared object file being produced.  */
3556   bfd_vma gp = (bfd_vma) - 1;
3557   /* The place (section offset or address) of the storage unit being
3558      relocated.  */
3559   bfd_vma p;
3560   /* The value of GP used to create the relocatable object.  */
3561   bfd_vma gp0 = (bfd_vma) - 1;
3562   /* The offset into the global offset table at which the address of
3563      the relocation entry symbol, adjusted by the addend, resides
3564      during execution.  */
3565   bfd_vma g = (bfd_vma) - 1;
3566   /* The section in which the symbol referenced by the relocation is
3567      located.  */
3568   asection *sec = NULL;
3569   struct mips_elf64_link_hash_entry* h = NULL;
3570   /* True if the symbol referred to by this relocation is a local
3571      symbol.  */
3572   boolean local_p;
3573   Elf_Internal_Shdr *symtab_hdr;
3574   size_t extsymoff;
3575   unsigned long r_symndx;
3576   int r_type;
3577   /* True if overflow occurred during the calculation of the
3578      relocation value.  */
3579   boolean overflowed_p;
3580   /* True if this relocation refers to a MIPS16 function.  */
3581   boolean target_is_16_bit_code_p = false;
3582
3583   /* Parse the relocation.  */
3584   r_symndx = ELF64_R_SYM (relocation->r_info);
3585   r_type = ELF64_MIPS_R_TYPE (relocation->r_info);
3586   p = (input_section->output_section->vma
3587        + input_section->output_offset
3588        + relocation->r_offset);
3589
3590   /* Assume that there will be no overflow.  */
3591   overflowed_p = false;
3592
3593   /* Figure out whether or not the symbol is local, and get the offset
3594      used in the array of hash table entries.  */
3595   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3596   local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3597                                          local_sections, false);
3598   if (! elf_bad_symtab (input_bfd))
3599     extsymoff = symtab_hdr->sh_info;
3600   else
3601     {
3602       /* The symbol table does not follow the rule that local symbols
3603          must come before globals.  */
3604       extsymoff = 0;
3605     }
3606
3607   /* Figure out the value of the symbol.  */
3608   if (local_p)
3609     {
3610       Elf_Internal_Sym *sym;
3611
3612       sym = local_syms + r_symndx;
3613       sec = local_sections[r_symndx];
3614
3615       symbol = sec->output_section->vma + sec->output_offset;
3616       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3617         symbol += sym->st_value;
3618
3619       /* MIPS16 text labels should be treated as odd.  */
3620       if (sym->st_other == STO_MIPS16)
3621         ++symbol;
3622
3623       /* Record the name of this symbol, for our caller.  */
3624       *namep = bfd_elf_string_from_elf_section (input_bfd,
3625                                                 symtab_hdr->sh_link,
3626                                                 sym->st_name);
3627       if (*namep == '\0')
3628         *namep = bfd_section_name (input_bfd, sec);
3629
3630       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3631     }
3632   else
3633     {
3634       /* For global symbols we look up the symbol in the hash-table.  */
3635       h = ((struct mips_elf64_link_hash_entry *)
3636            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3637       /* Find the real hash-table entry for this symbol.  */
3638       while (h->root.root.type == bfd_link_hash_indirect
3639              || h->root.root.type == bfd_link_hash_warning)
3640         h = (struct mips_elf64_link_hash_entry *) h->root.root.u.i.link;
3641
3642       /* Record the name of this symbol, for our caller.  */
3643       *namep = h->root.root.root.string;
3644
3645       /* If this symbol is defined, calculate its address.  */
3646       if ((h->root.root.type == bfd_link_hash_defined
3647            || h->root.root.type == bfd_link_hash_defweak)
3648           && h->root.root.u.def.section)
3649         {
3650           sec = h->root.root.u.def.section;
3651           if (sec->output_section)
3652             symbol = (h->root.root.u.def.value
3653                       + sec->output_section->vma
3654                       + sec->output_offset);
3655           else
3656             symbol = h->root.root.u.def.value;
3657         }
3658       else if (h->root.root.type == bfd_link_hash_undefweak)
3659         /* We allow relocations against undefined weak symbols, giving
3660            it the value zero, so that you can undefined weak functions
3661            and check to see if they exist by looking at their
3662            addresses.  */
3663         symbol = 0;
3664       else if (info->shared
3665                && (!info->symbolic || info->allow_shlib_undefined)
3666                && !info->no_undefined
3667                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3668         symbol = 0;
3669       else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
3670               strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
3671         {
3672           /* If this is a dynamic link, we should have created a
3673              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3674              in in mips_elf64_create_dynamic_sections.
3675              Otherwise, we should define the symbol with a value of 0.
3676              FIXME: It should probably get into the symbol table
3677              somehow as well.  */
3678           BFD_ASSERT (! info->shared);
3679           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3680           symbol = 0;
3681         }
3682       else
3683         {
3684           if (! ((*info->callbacks->undefined_symbol)
3685                  (info, h->root.root.root.string, input_bfd,
3686                   input_section, relocation->r_offset,
3687                   (!info->shared || info->no_undefined
3688                    || ELF_ST_VISIBILITY (h->root.other)))))
3689             return bfd_reloc_undefined;
3690           symbol = 0;
3691         }
3692
3693       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3694     }
3695
3696   /* If this is a 64-bit call to a 16-bit function with a stub, we
3697      need to redirect the call to the stub, unless we're already *in*
3698      a stub.  */
3699   if (r_type != R_MIPS16_26 && !info->relocateable
3700       && ((h != NULL && h->fn_stub != NULL)
3701           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3702               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3703       && !mips_elf64_stub_section_p (input_bfd, input_section))
3704     {
3705       /* This is a 64-bit call to a 16-bit function.  We should
3706          have already noticed that we were going to need the
3707          stub.  */
3708       if (local_p)
3709         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3710       else
3711         {
3712           BFD_ASSERT (h->need_fn_stub);
3713           sec = h->fn_stub;
3714         }
3715
3716       symbol = sec->output_section->vma + sec->output_offset;
3717     }
3718   /* If this is a 16-bit call to a 64-bit function with a stub, we
3719      need to redirect the call to the stub.  */
3720   else if (r_type == R_MIPS16_26 && !info->relocateable
3721            && h != NULL
3722            && (h->call_stub != NULL || h->call_fp_stub != NULL)
3723            && !target_is_16_bit_code_p)
3724     {
3725       /* If both call_stub and call_fp_stub are defined, we can figure
3726          out which one to use by seeing which one appears in the input
3727          file.  */
3728       if (h->call_stub != NULL && h->call_fp_stub != NULL)
3729         {
3730           asection *o;
3731
3732           sec = NULL;
3733           for (o = input_bfd->sections; o != NULL; o = o->next)
3734             {
3735               if (strncmp (bfd_get_section_name (input_bfd, o),
3736                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3737                 {
3738                   sec = h->call_fp_stub;
3739                   break;
3740                 }
3741             }
3742           if (sec == NULL)
3743             sec = h->call_stub;
3744         }
3745       else if (h->call_stub != NULL)
3746         sec = h->call_stub;
3747       else
3748         sec = h->call_fp_stub;
3749
3750       BFD_ASSERT (sec->_raw_size > 0);
3751       symbol = sec->output_section->vma + sec->output_offset;
3752     }
3753
3754   /* Calls from 16-bit code to 32-bit code and vice versa require the
3755      special jalx instruction.  */
3756   *require_jalxp = (!info->relocateable
3757                     && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
3758
3759   local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3760                                            local_sections, true);
3761
3762   /* If we haven't already determined the GOT offset, or the GP value,
3763      and we're going to need it, get it now.  */
3764   switch (r_type)
3765     {
3766     case R_MIPS_CALL16:
3767     case R_MIPS_GOT16:
3768     case R_MIPS_GOT_DISP:
3769     case R_MIPS_GOT_HI16:
3770     case R_MIPS_CALL_HI16:
3771     case R_MIPS_GOT_LO16:
3772     case R_MIPS_CALL_LO16:
3773       /* Find the index into the GOT where this value is located.  */
3774       if (!local_p)
3775         {
3776           BFD_ASSERT (addend == 0);
3777           g = mips_elf64_global_got_index (elf_hash_table (info)->dynobj,
3778                                          (struct elf_link_hash_entry*) h);
3779           if (! elf_hash_table(info)->dynamic_sections_created
3780               || (info->shared
3781                   && (info->symbolic || h->root.dynindx == -1)
3782                   && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3783             {
3784               /* This is a static link or a -Bsymbolic link.  The
3785                  symbol is defined locally, or was forced to be local.
3786                  We must initialize this entry in the GOT.  */
3787               bfd *tmpbfd = elf_hash_table (info)->dynobj;
3788
3789               asection *sgot = bfd_get_section_by_name (tmpbfd, ".got");
3790               bfd_put_64 (tmpbfd, symbol + addend, sgot->contents + g);
3791             }
3792         }
3793       else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3794         /* There's no need to create a local GOT entry here; the
3795            calculation for a local GOT16 entry does not involve G.  */
3796         break;
3797       else
3798         {
3799           g = mips_elf64_local_got_index (abfd, info, symbol + addend);
3800           if (g == (bfd_vma) -1)
3801             return false;
3802         }
3803
3804       /* Convert GOT indices to actual offsets.  */
3805       g = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3806                                             abfd, g);
3807       break;
3808
3809     case R_MIPS_HI16:
3810     case R_MIPS_LO16:
3811     case R_MIPS_GPREL16:
3812     case R_MIPS_GPREL32:
3813     case R_MIPS_LITERAL:
3814       gp0 = _bfd_get_gp_value (input_bfd);
3815       gp = _bfd_get_gp_value (abfd);
3816       break;
3817
3818     default:
3819       break;
3820     }
3821
3822   /* Figure out what kind of relocation is being performed.  */
3823   switch (r_type)
3824     {
3825     case R_MIPS_NONE:
3826       return bfd_reloc_continue;
3827
3828     case R_MIPS_16:
3829       value = symbol + mips_elf64_sign_extend (addend, 16);
3830       overflowed_p = mips_elf64_overflow_p (value, 16);
3831       break;
3832
3833     case R_MIPS_32:
3834     case R_MIPS_REL32:
3835     case R_MIPS_64:
3836       if ((info->shared
3837            || (elf_hash_table (info)->dynamic_sections_created
3838                && h != NULL
3839                && ((h->root.elf_link_hash_flags
3840                     & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3841                && ((h->root.elf_link_hash_flags
3842                     & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3843           && r_symndx != 0
3844           && (input_section->flags & SEC_ALLOC) != 0)
3845         {
3846           /* If we're creating a shared library, or this relocation is
3847              against a symbol in a shared library, then we can't know
3848              where the symbol will end up.  So, we create a relocation
3849              record in the output, and leave the job up to the dynamic
3850              linker.  */
3851           value = addend;
3852           if (!mips_elf64_create_dynamic_relocation (abfd, info, relocation,
3853                                                      h, sec, symbol, &value,
3854                                                      input_section))
3855             return false;
3856         }
3857       else
3858         {
3859           if (r_type != R_MIPS_REL32)
3860             value = symbol + addend;
3861           else
3862             value = addend;
3863         }
3864       value &= howto->dst_mask;
3865       break;
3866
3867     case R_MIPS_PC32:
3868     case R_MIPS_PC64:
3869     case R_MIPS_GNU_REL_LO16:
3870       value = symbol + addend - p;
3871       value &= howto->dst_mask;
3872       break;
3873
3874     case R_MIPS_GNU_REL16_S2:
3875       value = symbol + mips_elf64_sign_extend (addend << 2, 18) - p;
3876       overflowed_p = mips_elf64_overflow_p (value, 18);
3877       value = (value >> 2) & howto->dst_mask;
3878       break;
3879
3880     case R_MIPS_GNU_REL_HI16:
3881       value = mips_elf64_high (addend + symbol - p);
3882       value &= howto->dst_mask;
3883       break;
3884
3885     case R_MIPS16_26:
3886       /* The calculation for R_MIPS16_26 is just the same as for an
3887          R_MIPS_26.  It's only the storage of the relocated field into
3888          the output file that's different.  That's handled in
3889          mips_elf_perform_relocation.  So, we just fall through to the
3890          R_MIPS_26 case here.  */
3891     case R_MIPS_26:
3892       if (local_p)
3893         value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3894       else
3895         value = (mips_elf64_sign_extend (addend << 2, 28) + symbol) >> 2;
3896       value &= howto->dst_mask;
3897       break;
3898
3899     case R_MIPS_HI16:
3900       value = mips_elf64_high (addend + symbol);
3901       value &= howto->dst_mask;
3902       break;
3903
3904     case R_MIPS_LO16:
3905         value = (addend + symbol) & 0xffff;
3906         value &= howto->dst_mask;
3907       break;
3908
3909     case R_MIPS_LITERAL:
3910       /* Because we don't merge literal sections, we can handle this
3911          just like R_MIPS_GPREL16.  In the long run, we should merge
3912          shared literals, and then we will need to additional work
3913          here.  */
3914
3915       /* Fall through.  */
3916
3917     case R_MIPS_GPREL16:
3918       if (local_p)
3919         value = mips_elf64_sign_extend (addend, 16) + symbol + gp0 - gp;
3920       else
3921         value = mips_elf64_sign_extend (addend, 16) + symbol - gp;
3922       overflowed_p = mips_elf64_overflow_p (value, 16);
3923       break;
3924
3925     case R_MIPS_PC16:
3926       value = mips_elf64_sign_extend (addend, 16) + symbol - p;
3927       overflowed_p = mips_elf64_overflow_p (value, 16);
3928       value = (bfd_vma) ((bfd_signed_vma) value / 4);
3929       break;
3930
3931     case R_MIPS_GOT16:
3932     case R_MIPS_CALL16:
3933       if (local_p)
3934         {
3935           boolean forced;
3936
3937           /* The special case is when the symbol is forced to be local.  We
3938              need the full address in the GOT since no R_MIPS_LO16 relocation
3939              follows.  */
3940           forced = ! mips_elf64_local_relocation_p (input_bfd, relocation,
3941                                                   local_sections, false);
3942           value = mips_elf64_got16_entry (abfd, info, symbol + addend, forced);
3943           if (value == (bfd_vma) -1)
3944             return false;
3945           value
3946             = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3947                                               abfd,
3948                                               value);
3949           overflowed_p = mips_elf64_overflow_p (value, 16);
3950           break;
3951         }
3952
3953       /* Fall through.  */
3954
3955     case R_MIPS_GOT_DISP:
3956       value = g;
3957       overflowed_p = mips_elf64_overflow_p (value, 16);
3958       break;
3959
3960     case R_MIPS_GPREL32:
3961       value = (addend + symbol + gp0 - gp) & howto->dst_mask;
3962       break;
3963
3964     case R_MIPS_GOT_HI16:
3965     case R_MIPS_CALL_HI16:
3966       /* We're allowed to handle these two relocations identically.
3967          The dynamic linker is allowed to handle the CALL relocations
3968          differently by creating a lazy evaluation stub.  */
3969       value = g;
3970       value = mips_elf64_high (value);
3971       value &= howto->dst_mask;
3972       break;
3973
3974     case R_MIPS_GOT_LO16:
3975     case R_MIPS_CALL_LO16:
3976       value = g & howto->dst_mask;
3977       break;
3978
3979     case R_MIPS_GOT_PAGE:
3980       value = mips_elf64_got_page (abfd, info, symbol + addend, NULL);
3981       if (value == (bfd_vma) -1)
3982         return false;
3983       value = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3984                                               abfd,
3985                                               value);
3986       overflowed_p = mips_elf64_overflow_p (value, 16);
3987       break;
3988
3989     case R_MIPS_GOT_OFST:
3990       mips_elf64_got_page (abfd, info, symbol + addend, &value);
3991       overflowed_p = mips_elf64_overflow_p (value, 16);
3992       break;
3993
3994     case R_MIPS_SUB:
3995       value = symbol - addend;
3996       value &= howto->dst_mask;
3997       break;
3998
3999     case R_MIPS_HIGHER:
4000       value = mips_elf64_higher (addend + symbol);
4001       value &= howto->dst_mask;
4002       break;
4003
4004     case R_MIPS_HIGHEST:
4005       value = mips_elf64_highest (addend + symbol);
4006       value &= howto->dst_mask;
4007       break;
4008
4009     case R_MIPS_SCN_DISP:
4010       value = symbol + addend - sec->output_offset;
4011       value &= howto->dst_mask;
4012       break;
4013
4014     case R_MIPS_PJUMP:
4015     case R_MIPS_JALR:
4016       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
4017          hint; we could improve performance by honoring that hint.  */
4018       return bfd_reloc_continue;
4019
4020     case R_MIPS_GNU_VTINHERIT:
4021     case R_MIPS_GNU_VTENTRY:
4022       /* We don't do anything with these at present.  */
4023       return bfd_reloc_continue;
4024
4025     default:
4026       /* An unrecognized relocation type.  */
4027       return bfd_reloc_notsupported;
4028     }
4029
4030   /* Store the VALUE for our caller.  */
4031   *valuep = value;
4032   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
4033 }
4034 \f
4035 /* Obtain the field relocated by RELOCATION.  */
4036
4037 static bfd_vma
4038 mips_elf64_obtain_contents (howto, relocation, input_bfd, contents)
4039      reloc_howto_type *howto;
4040      const Elf_Internal_Rela *relocation;
4041      bfd *input_bfd;
4042      bfd_byte *contents;
4043 {
4044   bfd_byte *location = contents + relocation->r_offset;
4045
4046   /* Obtain the bytes.  */
4047   return bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
4048 }
4049
4050 /* It has been determined that the result of the RELOCATION is the
4051    VALUE.  Use HOWTO to place VALUE into the output file at the
4052    appropriate position.  The SECTION is the section to which the
4053    relocation applies.  If REQUIRE_JALX is true, then the opcode used
4054    for the relocation must be either JAL or JALX, and it is
4055    unconditionally converted to JALX.
4056
4057    Returns false if anything goes wrong.  */
4058
4059 static boolean
4060 mips_elf64_perform_relocation (info, howto, relocation, value,
4061                              input_bfd, input_section,
4062                              contents, require_jalx)
4063      struct bfd_link_info *info;
4064      reloc_howto_type *howto;
4065      const Elf_Internal_Rela *relocation;
4066      bfd_vma value;
4067      bfd *input_bfd;
4068      asection *input_section;
4069      bfd_byte *contents;
4070      boolean require_jalx;
4071 {
4072   bfd_vma x;
4073   bfd_byte *location;
4074   int r_type = ELF32_R_TYPE (relocation->r_info);
4075
4076   /* Figure out where the relocation is occurring.  */
4077   location = contents + relocation->r_offset;
4078
4079   /* Obtain the current value.  */
4080   x = mips_elf64_obtain_contents (howto, relocation, input_bfd, contents);
4081
4082   /* Clear the field we are setting.  */
4083   x &= ~howto->dst_mask;
4084
4085   /* If this is the R_MIPS16_26 relocation, we must store the
4086      value in a funny way.  */
4087   if (r_type == R_MIPS16_26)
4088     {
4089       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
4090          Most mips16 instructions are 16 bits, but these instructions
4091          are 32 bits.
4092
4093          The format of these instructions is:
4094
4095          +--------------+--------------------------------+
4096          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
4097          +--------------+--------------------------------+
4098          !                Immediate  15:0                   !
4099          +-----------------------------------------------+
4100
4101          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
4102          Note that the immediate value in the first word is swapped.
4103
4104          When producing a relocateable object file, R_MIPS16_26 is
4105          handled mostly like R_MIPS_26.  In particular, the addend is
4106          stored as a straight 26-bit value in a 32-bit instruction.
4107          (gas makes life simpler for itself by never adjusting a
4108          R_MIPS16_26 reloc to be against a section, so the addend is
4109          always zero).  However, the 32 bit instruction is stored as 2
4110          16-bit values, rather than a single 32-bit value.  In a
4111          big-endian file, the result is the same; in a little-endian
4112          file, the two 16-bit halves of the 32 bit value are swapped.
4113          This is so that a disassembler can recognize the jal
4114          instruction.
4115
4116          When doing a final link, R_MIPS16_26 is treated as a 32 bit
4117          instruction stored as two 16-bit values.  The addend A is the
4118          contents of the targ26 field.  The calculation is the same as
4119          R_MIPS_26.  When storing the calculated value, reorder the
4120          immediate value as shown above, and don't forget to store the
4121          value as two 16-bit values.
4122
4123          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
4124          defined as
4125
4126          big-endian:
4127          +--------+----------------------+
4128          |        |                      |
4129          |        |    targ26-16         |
4130          |31    26|25                   0|
4131          +--------+----------------------+
4132
4133          little-endian:
4134          +----------+------+-------------+
4135          |          |      |             |
4136          |  sub1    |      |     sub2    |
4137          |0        9|10  15|16         31|
4138          +----------+--------------------+
4139          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
4140          ((sub1 << 16) | sub2)).
4141
4142          When producing a relocateable object file, the calculation is
4143          (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4144          When producing a fully linked file, the calculation is
4145          let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4146          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
4147
4148       if (!info->relocateable)
4149         /* Shuffle the bits according to the formula above.  */
4150         value = (((value & 0x1f0000) << 5)
4151                  | ((value & 0x3e00000) >> 5)
4152                  | (value & 0xffff));
4153     }
4154   else if (r_type == R_MIPS16_GPREL)
4155     {
4156       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
4157          mode.  A typical instruction will have a format like this:
4158
4159          +--------------+--------------------------------+
4160          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
4161          +--------------+--------------------------------+
4162          !    Major     !   rx   !   ry   !   Imm  4:0   !
4163          +--------------+--------------------------------+
4164
4165          EXTEND is the five bit value 11110.  Major is the instruction
4166          opcode.
4167
4168          This is handled exactly like R_MIPS_GPREL16, except that the
4169          addend is retrieved and stored as shown in this diagram; that
4170          is, the Imm fields above replace the V-rel16 field.
4171
4172          All we need to do here is shuffle the bits appropriately.  As
4173          above, the two 16-bit halves must be swapped on a
4174          little-endian system.  */
4175       value = (((value & 0x7e0) << 16)
4176                | ((value & 0xf800) << 5)
4177                | (value & 0x1f));
4178     }
4179
4180   /* Set the field.  */
4181   x |= (value & howto->dst_mask);
4182
4183   /* If required, turn JAL into JALX.  */
4184   if (require_jalx)
4185     {
4186       boolean ok;
4187       bfd_vma opcode = x >> 26;
4188       bfd_vma jalx_opcode;
4189
4190       /* Check to see if the opcode is already JAL or JALX.  */
4191       if (r_type == R_MIPS16_26)
4192         {
4193           ok = ((opcode == 0x6) || (opcode == 0x7));
4194           jalx_opcode = 0x7;
4195         }
4196       else
4197         {
4198           ok = ((opcode == 0x3) || (opcode == 0x1d));
4199           jalx_opcode = 0x1d;
4200         }
4201
4202       /* If the opcode is not JAL or JALX, there's a problem.  */
4203       if (!ok)
4204         {
4205           (*_bfd_error_handler)
4206             (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
4207              bfd_archive_filename (input_bfd),
4208              input_section->name,
4209              (unsigned long) relocation->r_offset);
4210           bfd_set_error (bfd_error_bad_value);
4211           return false;
4212         }
4213
4214       /* Make this the JALX opcode.  */
4215       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
4216     }
4217
4218   /* Swap the high- and low-order 16 bits on little-endian systems
4219      when doing a MIPS16 relocation.  */
4220   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
4221       && bfd_little_endian (input_bfd))
4222     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
4223
4224   /* Put the value into the output.  */
4225   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
4226   return true;
4227 }
4228
4229 /* Returns true if SECTION is a MIPS16 stub section.  */
4230
4231 static boolean
4232 mips_elf64_stub_section_p (abfd, section)
4233      bfd *abfd ATTRIBUTE_UNUSED;
4234      asection *section;
4235 {
4236   const char *name = bfd_get_section_name (abfd, section);
4237
4238   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
4239           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
4240           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
4241 }
4242
4243 /* Relocate a MIPS ELF64 section.  */
4244
4245 static boolean
4246 mips_elf64_relocate_section (output_bfd, info, input_bfd, input_section,
4247                              contents, relocs, local_syms, local_sections)
4248      bfd *output_bfd;
4249      struct bfd_link_info *info;
4250      bfd *input_bfd;
4251      asection *input_section;
4252      bfd_byte *contents;
4253      Elf_Internal_Rela *relocs;
4254      Elf_Internal_Sym *local_syms;
4255      asection **local_sections;
4256 {
4257   Elf_Internal_Rela *rel;
4258   const Elf_Internal_Rela *relend;
4259   bfd_vma addend = 0;
4260   boolean use_saved_addend_p = false;
4261   struct elf_backend_data *bed;
4262
4263   bed = get_elf_backend_data (output_bfd);
4264   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
4265   for (rel = relocs; rel < relend; ++rel)
4266     {
4267       const char *name;
4268       bfd_vma value;
4269       reloc_howto_type *howto;
4270       boolean require_jalx;
4271       /* True if the relocation is a RELA relocation, rather than a
4272          REL relocation.  */
4273       boolean rela_relocation_p = true;
4274       int r_type = ELF64_MIPS_R_TYPE (rel->r_info);
4275       const char *msg = (const char *) NULL;
4276
4277       /* Find the relocation howto for this relocation.  */
4278       howto = &mips_elf64_howto_table_rela[r_type];
4279
4280       if (!use_saved_addend_p)
4281         {
4282           Elf_Internal_Shdr *rel_hdr;
4283
4284           /* If these relocations were originally of the REL variety,
4285              we must pull the addend out of the field that will be
4286              relocated.  Otherwise, we simply use the contents of the
4287              RELA relocation.  To determine which flavor or relocation
4288              this is, we depend on the fact that the INPUT_SECTION's
4289              REL_HDR is read before its REL_HDR2.  */
4290           rel_hdr = &elf_section_data (input_section)->rel_hdr;
4291           if ((size_t) (rel - relocs)
4292               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
4293             rel_hdr = elf_section_data (input_section)->rel_hdr2;
4294           if (rel_hdr->sh_entsize
4295               == (get_elf_backend_data (input_bfd)->s->sizeof_rel))
4296             {
4297               /* Note that this is a REL relocation.  */
4298               rela_relocation_p = false;
4299
4300               /* Find the relocation howto for this relocation.  */
4301               howto = &mips_elf64_howto_table_rel[r_type];
4302
4303               /* Get the addend, which is stored in the input file.  */
4304               addend = mips_elf64_obtain_contents (howto,
4305                                                    rel,
4306                                                    input_bfd,
4307                                                    contents);
4308               addend &= howto->src_mask;
4309
4310               /* For some kinds of relocations, the ADDEND is a
4311                  combination of the addend stored in two different
4312                  relocations.   */
4313               if (r_type == R_MIPS_HI16
4314                   || r_type == R_MIPS_GNU_REL_HI16
4315                   || (r_type == R_MIPS_GOT16
4316                       && mips_elf64_local_relocation_p (input_bfd, rel,
4317                                                       local_sections, false)))
4318                 {
4319                   bfd_vma l;
4320                   const Elf_Internal_Rela *lo16_relocation;
4321                   reloc_howto_type *lo16_howto;
4322                   int lo;
4323
4324                   /* The combined value is the sum of the HI16 addend,
4325                      left-shifted by sixteen bits, and the LO16
4326                      addend, sign extended.  (Usually, the code does
4327                      a `lui' of the HI16 value, and then an `addiu' of
4328                      the LO16 value.)
4329
4330                      Scan ahead to find a matching LO16 relocation.  */
4331                   if (r_type == R_MIPS_GNU_REL_HI16)
4332                     lo = R_MIPS_GNU_REL_LO16;
4333                   else
4334                     lo = R_MIPS_LO16;
4335                   lo16_relocation
4336                     = mips_elf64_next_relocation (lo, rel, relend);
4337                   if (lo16_relocation == NULL)
4338                     return false;
4339
4340                   /* Obtain the addend kept there.  */
4341                   if (rela_relocation_p == false)
4342                     lo16_howto = &mips_elf64_howto_table_rel[lo];
4343                   else
4344                     lo16_howto = &mips_elf64_howto_table_rela[lo];
4345                   l = mips_elf64_obtain_contents (lo16_howto,
4346                                                 lo16_relocation,
4347                                                 input_bfd, contents);
4348                   l &= lo16_howto->src_mask;
4349                   l = mips_elf64_sign_extend (l, 16);
4350
4351                   addend <<= 16;
4352
4353                   /* Compute the combined addend.  */
4354                   addend += l;
4355                 }
4356             }
4357           else
4358             addend = rel->r_addend;
4359         }
4360
4361       if (info->relocateable)
4362         {
4363           Elf_Internal_Sym *sym;
4364           unsigned long r_symndx;
4365
4366           /* Since we're just relocating, all we need to do is copy
4367              the relocations back out to the object file, unless
4368              they're against a section symbol, in which case we need
4369              to adjust by the section offset, or unless they're GP
4370              relative in which case we need to adjust by the amount
4371              that we're adjusting GP in this relocateable object.  */
4372
4373           if (!mips_elf64_local_relocation_p (input_bfd, rel, local_sections,
4374                                             false))
4375             /* There's nothing to do for non-local relocations.  */
4376             continue;
4377
4378           if (r_type == R_MIPS_GPREL16
4379               || r_type == R_MIPS_GPREL32
4380               || r_type == R_MIPS_LITERAL)
4381             addend -= (_bfd_get_gp_value (output_bfd)
4382                        - _bfd_get_gp_value (input_bfd));
4383           else if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4384             /* The addend is stored without its two least
4385                significant bits (which are always zero.)  In a
4386                non-relocateable link, calculate_relocation will do
4387                this shift; here, we must do it ourselves.  */
4388             addend <<= 2;
4389
4390           r_symndx = ELF64_R_SYM (rel->r_info);
4391           sym = local_syms + r_symndx;
4392           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4393             /* Adjust the addend appropriately.  */
4394             addend += local_sections[r_symndx]->output_offset;
4395
4396 #if 0
4397           /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
4398              then we only want to write out the high-order 16 bits.
4399              The subsequent R_MIPS_LO16 will handle the low-order bits.  */
4400           if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
4401               || r_type == R_MIPS_GNU_REL_HI16)
4402             addend = mips_elf64_high (addend);
4403           else if (r_type == R_MIPS_HIGHER)
4404             addend = mips_elf64_higher (addend);
4405           else if (r_type == R_MIPS_HIGHEST)
4406             addend = mips_elf64_highest (addend);
4407 #endif
4408           /* If the relocation is for an R_MIPS_26 relocation, then
4409              the two low-order bits are not stored in the object file;
4410              they are implicitly zero.  */
4411           if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4412             addend >>= 2;
4413
4414           if (rela_relocation_p)
4415             /* If this is a RELA relocation, just update the addend.
4416                We have to cast away constness for REL.  */
4417             rel->r_addend = addend;
4418           else
4419             {
4420               /* Otherwise, we have to write the value back out.  Note
4421                  that we use the source mask, rather than the
4422                  destination mask because the place to which we are
4423                  writing will be source of the addend in the final
4424                  link.  */
4425               addend &= howto->src_mask;
4426
4427               if (!mips_elf64_perform_relocation (info, howto, rel, addend,
4428                                                   input_bfd, input_section,
4429                                                   contents, false))
4430                 return false;
4431             }
4432
4433           /* Go on to the next relocation.  */
4434           continue;
4435         }
4436
4437       /* In the N32 and 64-bit ABIs there may be multiple consecutive
4438          relocations for the same offset.  In that case we are
4439          supposed to treat the output of each relocation as the addend
4440          for the next.  */
4441       if (rel + 1 < relend
4442           && rel->r_offset == rel[1].r_offset
4443           && ELF64_MIPS_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
4444         use_saved_addend_p = true;
4445       else
4446         use_saved_addend_p = false;
4447
4448       /* Figure out what value we are supposed to relocate.  */
4449       switch (mips_elf64_calculate_relocation (output_bfd, input_bfd,
4450                                                input_section, info, rel,
4451                                                addend, howto, local_syms,
4452                                                local_sections, &value, &name,
4453                                                &require_jalx))
4454         {
4455         case bfd_reloc_continue:
4456           /* There's nothing to do.  */
4457           continue;
4458
4459         case bfd_reloc_undefined:
4460           /* mips_elf64_calculate_relocation already called the
4461              undefined_symbol callback.  There's no real point in
4462              trying to perform the relocation at this point, so we
4463              just skip ahead to the next relocation.  */
4464           continue;
4465
4466         case bfd_reloc_notsupported:
4467           msg = _("internal error: unsupported relocation error");
4468           info->callbacks->warning
4469             (info, msg, name, input_bfd, input_section, rel->r_offset);
4470           return false;
4471
4472         case bfd_reloc_overflow:
4473           if (use_saved_addend_p)
4474             /* Ignore overflow until we reach the last relocation for
4475                a given location.  */
4476             ;
4477           else
4478             {
4479               BFD_ASSERT (name != NULL);
4480               if (! ((*info->callbacks->reloc_overflow)
4481                      (info, name, howto->name, (bfd_vma) 0,
4482                       input_bfd, input_section, rel->r_offset)))
4483                 return false;
4484             }
4485           break;
4486
4487         case bfd_reloc_ok:
4488           break;
4489
4490         default:
4491           abort ();
4492           break;
4493         }
4494
4495       /* If we've got another relocation for the address, keep going
4496          until we reach the last one.  */
4497       if (use_saved_addend_p)
4498         {
4499           addend = value;
4500           continue;
4501         }
4502
4503       /* Actually perform the relocation.  */
4504       if (!mips_elf64_perform_relocation (info, howto, rel, value, input_bfd,
4505                                           input_section, contents,
4506                                           require_jalx))
4507         return false;
4508     }
4509
4510   return true;
4511 }
4512
4513 /* Create dynamic sections when linking against a dynamic object.  */
4514
4515 boolean
4516 mips_elf64_create_dynamic_sections (abfd, info)
4517      bfd *abfd;
4518      struct bfd_link_info *info;
4519 {
4520   flagword flags;
4521   register asection *s;
4522
4523   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4524            | SEC_LINKER_CREATED | SEC_READONLY);
4525
4526   /* Mips ABI requests the .dynamic section to be read only.  */
4527   s = bfd_get_section_by_name (abfd, ".dynamic");
4528   if (s != NULL)
4529     {
4530       if (! bfd_set_section_flags (abfd, s, flags))
4531         return false;
4532     }
4533
4534   /* We need to create .got section.  */
4535   if (! mips_elf64_create_got_section (abfd, info))
4536     return false;
4537
4538   /* Create the .msym section on IRIX6.  It is used by the dynamic
4539      linker to speed up dynamic relocations, and to avoid computing
4540      the ELF hash for symbols.  */
4541   if (!mips_elf64_create_msym_section (abfd))
4542     return false;
4543
4544   /* Create .stub section.  */
4545   if (bfd_get_section_by_name (abfd, ".MIPS.stubs") == NULL)
4546     {
4547       s = bfd_make_section (abfd, ".MIPS.stubs");
4548       if (s == NULL
4549           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4550           || ! bfd_set_section_alignment (abfd, s, 3))
4551         return false;
4552     }
4553
4554   return true;
4555 }
4556
4557 /* Adjust a symbol defined by a dynamic object and referenced by a
4558    regular object.  The current definition is in some section of the
4559    dynamic object, but we're not including those sections.  We have to
4560    change the definition to something the rest of the link can
4561    understand.  */
4562
4563 boolean
4564 mips_elf64_adjust_dynamic_symbol (info, h)
4565      struct bfd_link_info *info;
4566      struct elf_link_hash_entry *h;
4567 {
4568   bfd *dynobj;
4569   struct mips_elf64_link_hash_entry *hmips;
4570   asection *s;
4571
4572   dynobj = elf_hash_table (info)->dynobj;
4573
4574   /* Make sure we know what is going on here.  */
4575   BFD_ASSERT (dynobj != NULL
4576               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
4577                   || h->weakdef != NULL
4578                   || ((h->elf_link_hash_flags
4579                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4580                       && (h->elf_link_hash_flags
4581                           & ELF_LINK_HASH_REF_REGULAR) != 0
4582                       && (h->elf_link_hash_flags
4583                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
4584
4585   /* If this symbol is defined in a dynamic object, we need to copy
4586      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
4587      file.  */
4588   hmips = (struct mips_elf64_link_hash_entry *) h;
4589   if (! info->relocateable
4590       && hmips->possibly_dynamic_relocs != 0
4591       && (h->root.type == bfd_link_hash_defweak
4592           || (h->elf_link_hash_flags
4593               & ELF_LINK_HASH_DEF_REGULAR) == 0))
4594     {
4595       mips_elf64_allocate_dynamic_relocations (dynobj,
4596                                                hmips->possibly_dynamic_relocs);
4597       if (hmips->readonly_reloc)
4598         /* We tell the dynamic linker that there are relocations
4599            against the text segment.  */
4600         info->flags |= DF_TEXTREL;
4601     }
4602
4603   /* For a function, create a stub, if allowed.  */
4604   if (! hmips->no_fn_stub
4605       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4606     {
4607       if (! elf_hash_table (info)->dynamic_sections_created)
4608         return true;
4609
4610       /* If this symbol is not defined in a regular file, then set
4611          the symbol to the stub location.  This is required to make
4612          function pointers compare as equal between the normal
4613          executable and the shared library.  */
4614       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4615         {
4616           /* We need .stub section.  */
4617           s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
4618           BFD_ASSERT (s != NULL);
4619
4620           h->root.u.def.section = s;
4621           h->root.u.def.value = s->_raw_size;
4622
4623           /* XXX Write this stub address somewhere.  */
4624           h->plt.offset = s->_raw_size;
4625
4626           /* Make room for this stub code.  */
4627           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4628
4629           /* The last half word of the stub will be filled with the index
4630              of this symbol in .dynsym section.  */
4631           return true;
4632         }
4633     }
4634   else if ((h->type == STT_FUNC)
4635            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
4636     {
4637       /* This will set the entry for this symbol in the GOT to 0, and
4638          the dynamic linker will take care of this.  */
4639       h->root.u.def.value = 0;
4640       return true;
4641     }
4642
4643   /* If this is a weak symbol, and there is a real definition, the
4644      processor independent code will have arranged for us to see the
4645      real definition first, and we can just use the same value.  */
4646   if (h->weakdef != NULL)
4647     {
4648       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
4649                   || h->weakdef->root.type == bfd_link_hash_defweak);
4650       h->root.u.def.section = h->weakdef->root.u.def.section;
4651       h->root.u.def.value = h->weakdef->root.u.def.value;
4652       return true;
4653     }
4654
4655   /* This is a reference to a symbol defined by a dynamic object which
4656      is not a function.  */
4657
4658   return true;
4659 }
4660
4661 /* This function is called after all the input files have been read,
4662    and the input sections have been assigned to output sections.  */
4663
4664 boolean
4665 mips_elf64_always_size_sections (output_bfd, info)
4666      bfd *output_bfd ATTRIBUTE_UNUSED;
4667      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4668 {
4669   if (info->relocateable
4670       || ! mips_elf64_hash_table (info)->mips16_stubs_seen)
4671     return true;
4672
4673   mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
4674                                  mips_elf64_check_mips16_stubs,
4675                                  (PTR) NULL);
4676
4677   return true;
4678 }
4679
4680 /* Check the mips16 stubs for a particular symbol, and see if we can
4681    discard them.  */
4682
4683 static boolean
4684 mips_elf64_check_mips16_stubs (h, data)
4685      struct mips_elf64_link_hash_entry *h;
4686      PTR data ATTRIBUTE_UNUSED;
4687 {
4688   if (h->fn_stub != NULL
4689       && ! h->need_fn_stub)
4690     {
4691       /* We don't need the fn_stub; the only references to this symbol
4692          are 16 bit calls.  Clobber the size to 0 to prevent it from
4693          being included in the link.  */
4694       h->fn_stub->_raw_size = 0;
4695       h->fn_stub->_cooked_size = 0;
4696       h->fn_stub->flags &= ~SEC_RELOC;
4697       h->fn_stub->reloc_count = 0;
4698       h->fn_stub->flags |= SEC_EXCLUDE;
4699     }
4700
4701   if (h->call_stub != NULL
4702       && h->root.other == STO_MIPS16)
4703     {
4704       /* We don't need the call_stub; this is a 16 bit function, so
4705          calls from other 16 bit functions are OK.  Clobber the size
4706          to 0 to prevent it from being included in the link.  */
4707       h->call_stub->_raw_size = 0;
4708       h->call_stub->_cooked_size = 0;
4709       h->call_stub->flags &= ~SEC_RELOC;
4710       h->call_stub->reloc_count = 0;
4711       h->call_stub->flags |= SEC_EXCLUDE;
4712     }
4713
4714   if (h->call_fp_stub != NULL
4715       && h->root.other == STO_MIPS16)
4716     {
4717       /* We don't need the call_stub; this is a 16 bit function, so
4718          calls from other 16 bit functions are OK.  Clobber the size
4719          to 0 to prevent it from being included in the link.  */
4720       h->call_fp_stub->_raw_size = 0;
4721       h->call_fp_stub->_cooked_size = 0;
4722       h->call_fp_stub->flags &= ~SEC_RELOC;
4723       h->call_fp_stub->reloc_count = 0;
4724       h->call_fp_stub->flags |= SEC_EXCLUDE;
4725     }
4726
4727   return true;
4728 }
4729
4730 /* Set the sizes of the dynamic sections.  */
4731
4732 boolean
4733 mips_elf64_size_dynamic_sections (output_bfd, info)
4734      bfd *output_bfd;
4735      struct bfd_link_info *info;
4736 {
4737   bfd *dynobj;
4738   asection *s;
4739   boolean reltext;
4740   struct mips_elf64_got_info *g = NULL;
4741
4742   dynobj = elf_hash_table (info)->dynobj;
4743   BFD_ASSERT (dynobj != NULL);
4744
4745   if (elf_hash_table (info)->dynamic_sections_created)
4746     {
4747       /* Set the contents of the .interp section to the interpreter.  */
4748       if (! info->shared)
4749         {
4750           s = bfd_get_section_by_name (dynobj, ".interp");
4751           BFD_ASSERT (s != NULL);
4752           s->_raw_size = strlen ("/usr/lib64/libc.so.1") + 1;
4753           s->contents = (bfd_byte *) "/usr/lib64/libc.so.1";
4754         }
4755     }
4756
4757   /* The check_relocs and adjust_dynamic_symbol entry points have
4758      determined the sizes of the various dynamic sections.  Allocate
4759      memory for them.  */
4760   reltext = false;
4761   for (s = dynobj->sections; s != NULL; s = s->next)
4762     {
4763       const char *name;
4764       boolean strip;
4765
4766       /* It's OK to base decisions on the section name, because none
4767          of the dynobj section names depend upon the input files.  */
4768       name = bfd_get_section_name (dynobj, s);
4769
4770       if ((s->flags & SEC_LINKER_CREATED) == 0)
4771         continue;
4772
4773       strip = false;
4774
4775       if (strncmp (name, ".rel", 4) == 0)
4776         {
4777           if (s->_raw_size == 0)
4778             {
4779               /* We only strip the section if the output section name
4780                  has the same name.  Otherwise, there might be several
4781                  input sections for this output section.  FIXME: This
4782                  code is probably not needed these days anyhow, since
4783                  the linker now does not create empty output sections.  */
4784               if (s->output_section != NULL
4785                   && strcmp (name,
4786                              bfd_get_section_name (s->output_section->owner,
4787                                                    s->output_section)) == 0)
4788                 strip = true;
4789             }
4790           else
4791             {
4792               const char *outname;
4793               asection *target;
4794
4795               /* If this relocation section applies to a read only
4796                  section, then we probably need a DT_TEXTREL entry.
4797                  If the relocation section is .rel.dyn, we always
4798                  assert a DT_TEXTREL entry rather than testing whether
4799                  there exists a relocation to a read only section or
4800                  not.  */
4801               outname = bfd_get_section_name (output_bfd,
4802                                               s->output_section);
4803               target = bfd_get_section_by_name (output_bfd, outname + 4);
4804               if ((target != NULL
4805                    && (target->flags & SEC_READONLY) != 0
4806                    && (target->flags & SEC_ALLOC) != 0)
4807                   || strcmp (outname, "rel.dyn") == 0)
4808                 reltext = true;
4809
4810               /* We use the reloc_count field as a counter if we need
4811                  to copy relocs into the output file.  */
4812               if (strcmp (name, "rel.dyn") != 0)
4813                 s->reloc_count = 0;
4814             }
4815         }
4816       else if (strncmp (name, ".got", 4) == 0)
4817         {
4818           int i;
4819           bfd_size_type loadable_size = 0;
4820           bfd_size_type local_gotno;
4821           bfd *sub;
4822
4823           BFD_ASSERT (elf_section_data (s) != NULL);
4824           g = (struct mips_elf64_got_info *) elf_section_data (s)->tdata;
4825           BFD_ASSERT (g != NULL);
4826
4827           /* Calculate the total loadable size of the output.  That
4828              will give us the maximum number of GOT_PAGE entries
4829              required.  */
4830           for (sub = info->input_bfds; sub; sub = sub->link_next)
4831             {
4832               asection *subsection;
4833
4834               for (subsection = sub->sections;
4835                    subsection;
4836                    subsection = subsection->next)
4837                 {
4838                   if ((subsection->flags & SEC_ALLOC) == 0)
4839                     continue;
4840                   loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
4841                 }
4842             }
4843           loadable_size += MIPS_FUNCTION_STUB_SIZE;
4844
4845           /* Assume there are two loadable segments consisting of
4846              contiguous sections.  Is 5 enough?  */
4847           local_gotno = (loadable_size >> 16) + 5;
4848             /* It's possible we will need GOT_PAGE entries as well as
4849                GOT16 entries.  Often, these will be able to share GOT
4850                entries, but not always.  */
4851             local_gotno *= 2;
4852
4853           g->local_gotno += local_gotno;
4854           s->_raw_size += local_gotno * 8;
4855
4856           /* There has to be a global GOT entry for every symbol with
4857              a dynamic symbol table index of DT_MIPS_GOTSYM or
4858              higher.  Therefore, it make sense to put those symbols
4859              that need GOT entries at the end of the symbol table.  We
4860              do that here.  */
4861           if (!mips_elf64_sort_hash_table (info, 1))
4862             return false;
4863
4864           if (g->global_gotsym != NULL)
4865             i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
4866           else
4867             /* If there are no global symbols, or none requiring
4868                relocations, then GLOBAL_GOTSYM will be NULL.  */
4869             i = 0;
4870           g->global_gotno = i;
4871           s->_raw_size += i * 8;
4872         }
4873       else if (strcmp (name, ".MIPS.stubs") == 0)
4874         {
4875           /* Irix rld assumes that the function stub isn't at the end
4876              of .text section. So put a dummy. XXX  */
4877           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4878         }
4879       else if (strcmp (name, ".msym")
4880                == 0)
4881         s->_raw_size = (sizeof (Elf32_External_Msym)
4882                         * (elf_hash_table (info)->dynsymcount
4883                            + bfd_count_sections (output_bfd)));
4884       else if (strncmp (name, ".init", 5) != 0)
4885         {
4886           /* It's not one of our sections, so don't allocate space.  */
4887           continue;
4888         }
4889
4890       if (strip)
4891         {
4892           _bfd_strip_section_from_output (info, s);
4893           continue;
4894         }
4895
4896       /* Allocate memory for the section contents.  */
4897       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4898       if (s->contents == NULL && s->_raw_size != 0)
4899         {
4900           bfd_set_error (bfd_error_no_memory);
4901           return false;
4902         }
4903     }
4904
4905   if (elf_hash_table (info)->dynamic_sections_created)
4906     {
4907       /* Add some entries to the .dynamic section.  We fill in the
4908          values later, in elf_mips_finish_dynamic_sections, but we
4909          must add the entries now so that we get the correct size for
4910          the .dynamic section.  The DT_DEBUG entry is filled in by the
4911          dynamic linker and used by the debugger.  */
4912       if (! info->shared)
4913         {
4914           /* SGI object has the equivalence of DT_DEBUG in the
4915              DT_MIPS_RLD_MAP entry.  */
4916           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_MAP, 0))
4917             return false;
4918           if (!SGI_COMPAT (output_bfd))
4919             {
4920               if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4921                 return false;
4922             }
4923         }
4924       else
4925         {
4926           /* Shared libraries on traditional mips have DT_DEBUG.  */
4927           if (!SGI_COMPAT (output_bfd))
4928             {
4929               if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4930                 return false;
4931             }
4932         }
4933
4934       if (reltext && SGI_COMPAT (output_bfd))
4935         info->flags |= DF_TEXTREL;
4936
4937       if ((info->flags & DF_TEXTREL) != 0)
4938         {
4939           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
4940             return false;
4941         }
4942
4943       if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
4944         return false;
4945
4946       if (bfd_get_section_by_name (dynobj, "rel.dyn"))
4947         {
4948           if (! bfd_elf64_add_dynamic_entry (info, DT_REL, 0))
4949             return false;
4950
4951           if (! bfd_elf64_add_dynamic_entry (info, DT_RELSZ, 0))
4952             return false;
4953
4954           if (! bfd_elf64_add_dynamic_entry (info, DT_RELENT, 0))
4955             return false;
4956         }
4957
4958       if (SGI_COMPAT (output_bfd))
4959         {
4960           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICTNO, 0))
4961             return false;
4962         }
4963
4964       if (SGI_COMPAT (output_bfd))
4965         {
4966           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLISTNO, 0))
4967             return false;
4968         }
4969
4970       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
4971         {
4972           if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICT, 0))
4973             return false;
4974
4975           s = bfd_get_section_by_name (dynobj, ".liblist");
4976           BFD_ASSERT (s != NULL);
4977
4978           if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLIST, 0))
4979             return false;
4980         }
4981
4982       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_VERSION, 0))
4983         return false;
4984
4985       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_FLAGS, 0))
4986         return false;
4987
4988 #if 0
4989       /* Time stamps in executable files are a bad idea.  */
4990       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_TIME_STAMP, 0))
4991         return false;
4992 #endif
4993
4994 #if 0 /* FIXME  */
4995       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_ICHECKSUM, 0))
4996         return false;
4997 #endif
4998
4999 #if 0 /* FIXME  */
5000       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_IVERSION, 0))
5001         return false;
5002 #endif
5003
5004       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_BASE_ADDRESS, 0))
5005         return false;
5006
5007       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LOCAL_GOTNO, 0))
5008         return false;
5009
5010       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_SYMTABNO, 0))
5011         return false;
5012
5013       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_UNREFEXTNO, 0))
5014         return false;
5015
5016       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_GOTSYM, 0))
5017         return false;
5018
5019       if ((bfd_get_section_by_name(dynobj, ".MIPS.options"))
5020           && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_OPTIONS, 0))
5021         return false;
5022
5023       if (bfd_get_section_by_name (dynobj, ".msym")
5024           && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_MSYM, 0))
5025         return false;
5026     }
5027
5028   return true;
5029 }
5030
5031 /* Finish up dynamic symbol handling.  We set the contents of various
5032    dynamic sections here.  */
5033
5034 boolean
5035 mips_elf64_finish_dynamic_symbol (output_bfd, info, h, sym)
5036      bfd *output_bfd;
5037      struct bfd_link_info *info;
5038      struct elf_link_hash_entry *h;
5039      Elf_Internal_Sym *sym;
5040 {
5041   bfd *dynobj;
5042   bfd_vma gval;
5043   asection *sgot;
5044   asection *smsym;
5045   struct mips_elf64_got_info *g;
5046   const char *name;
5047   struct mips_elf64_link_hash_entry *mh;
5048
5049   dynobj = elf_hash_table (info)->dynobj;
5050   gval = sym->st_value;
5051   mh = (struct mips_elf64_link_hash_entry *) h;
5052
5053   if (h->plt.offset != (bfd_vma) -1)
5054     {
5055       asection *s;
5056       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
5057
5058       /* This symbol has a stub.  Set it up.  */
5059
5060       BFD_ASSERT (h->dynindx != -1);
5061
5062       s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
5063       BFD_ASSERT (s != NULL);
5064
5065       /* FIXME: Can h->dynindex be more than 64K?  */
5066       if (h->dynindx & 0xffff0000)
5067         return false;
5068
5069       /* Fill the stub.  */
5070       bfd_put_32 (output_bfd, STUB_LW, stub);
5071       bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
5072       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
5073       bfd_put_32 (output_bfd, STUB_LI16 + h->dynindx, stub + 12);
5074
5075       BFD_ASSERT (h->plt.offset <= s->_raw_size);
5076       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
5077
5078       /* Mark the symbol as undefined.  plt.offset != -1 occurs
5079          only for the referenced symbol.  */
5080       sym->st_shndx = SHN_UNDEF;
5081
5082       /* The run-time linker uses the st_value field of the symbol
5083          to reset the global offset table entry for this external
5084          to its stub address when unlinking a shared object.  */
5085       gval = s->output_section->vma + s->output_offset + h->plt.offset;
5086       sym->st_value = gval;
5087     }
5088
5089   BFD_ASSERT (h->dynindx != -1
5090               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
5091
5092   sgot = bfd_get_section_by_name (dynobj, ".got");
5093   BFD_ASSERT (sgot != NULL);
5094   BFD_ASSERT (elf_section_data (sgot) != NULL);
5095   g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5096   BFD_ASSERT (g != NULL);
5097
5098   /* Run through the global symbol table, creating GOT entries for all
5099      the symbols that need them.  */
5100   if (g->global_gotsym != NULL
5101       && h->dynindx >= g->global_gotsym->dynindx)
5102     {
5103       bfd_vma offset;
5104       bfd_vma value;
5105
5106       if (sym->st_value)
5107         value = sym->st_value;
5108       else
5109         {
5110           /* For an entity defined in a shared object, this will be
5111              NULL.  (For functions in shared objects for
5112              which we have created stubs, ST_VALUE will be non-NULL.
5113              That's because such the functions are now no longer defined
5114              in a shared object.)  */
5115
5116           if (info->shared && h->root.type == bfd_link_hash_undefined)
5117             value = 0;
5118           else
5119             value = h->root.u.def.value;
5120         }
5121       offset = mips_elf64_global_got_index (dynobj, h);
5122       bfd_put_64 (output_bfd, value, sgot->contents + offset);
5123     }
5124
5125   /* Create a .msym entry, if appropriate.  */
5126   smsym = bfd_get_section_by_name (dynobj, ".msym");
5127   if (smsym)
5128     {
5129       Elf32_Internal_Msym msym;
5130
5131       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
5132       /* It is undocumented what the `1' indicates, but IRIX6 uses
5133          this value.  */
5134       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
5135       mips_elf64_swap_msym_out
5136         (dynobj, &msym,
5137          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
5138     }
5139
5140   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5141   name = h->root.root.string;
5142   if (strcmp (name, "_DYNAMIC") == 0
5143       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
5144     sym->st_shndx = SHN_ABS;
5145   else if (strcmp (name, "_DYNAMIC_LINK") == 0
5146            || strcmp (name, "_DYNAMIC_LINKING") == 0)
5147     {
5148       sym->st_shndx = SHN_ABS;
5149       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5150       sym->st_value = 1;
5151     }
5152   else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
5153     {
5154       if (h->type == STT_FUNC)
5155         sym->st_shndx = SHN_MIPS_TEXT;
5156       else if (h->type == STT_OBJECT)
5157         sym->st_shndx = SHN_MIPS_DATA;
5158     }
5159
5160   /* Handle the IRIX6-specific symbols.  */
5161
5162     {
5163   /* The linker script takes care of providing names and values for
5164      these, but we must place them into the right sections.  */
5165   static const char* const text_section_symbols[] = {
5166     "_ftext",
5167     "_etext",
5168     "__dso_displacement",
5169     "__elf_header",
5170     "__program_header_table",
5171     NULL
5172   };
5173
5174   static const char* const data_section_symbols[] = {
5175     "_fdata",
5176     "_edata",
5177     "_end",
5178     "_fbss",
5179     NULL
5180   };
5181
5182   const char* const *p;
5183   int i;
5184
5185   for (i = 0; i < 2; ++i)
5186     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
5187          *p;
5188          ++p)
5189       if (strcmp (*p, name) == 0)
5190         {
5191           /* All of these symbols are given type STT_SECTION by the
5192              IRIX6 linker.  */
5193           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5194
5195           /* The IRIX linker puts these symbols in special sections.  */
5196           if (i == 0)
5197             sym->st_shndx = SHN_MIPS_TEXT;
5198           else
5199             sym->st_shndx = SHN_MIPS_DATA;
5200
5201           break;
5202         }
5203     }
5204
5205   return true;
5206 }
5207
5208 /* Finish up the dynamic sections.  */
5209
5210 boolean
5211 mips_elf64_finish_dynamic_sections (output_bfd, info)
5212      bfd *output_bfd;
5213      struct bfd_link_info *info;
5214 {
5215   bfd *dynobj;
5216   asection *sdyn;
5217   asection *sgot;
5218   struct mips_elf64_got_info *g;
5219
5220   dynobj = elf_hash_table (info)->dynobj;
5221
5222   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5223
5224   sgot = bfd_get_section_by_name (dynobj, ".got");
5225   if (sgot == NULL)
5226     g = NULL;
5227   else
5228     {
5229       BFD_ASSERT (elf_section_data (sgot) != NULL);
5230       g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5231       BFD_ASSERT (g != NULL);
5232     }
5233
5234   if (elf_hash_table (info)->dynamic_sections_created)
5235     {
5236       bfd_byte *b;
5237
5238       BFD_ASSERT (sdyn != NULL);
5239       BFD_ASSERT (g != NULL);
5240
5241       for (b = sdyn->contents;
5242            b < sdyn->contents + sdyn->_raw_size;
5243            b += get_elf_backend_data (dynobj)->s->sizeof_dyn)
5244         {
5245           Elf_Internal_Dyn dyn;
5246           const char *name;
5247           size_t elemsize;
5248           asection *s;
5249           boolean swap_out_p;
5250
5251           /* Read in the current dynamic entry.  */
5252           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
5253
5254           /* Assume that we're going to modify it and write it out.  */
5255           swap_out_p = true;
5256
5257           switch (dyn.d_tag)
5258             {
5259             case DT_RELENT:
5260               s = bfd_get_section_by_name(dynobj, "rel.dyn");
5261               BFD_ASSERT (s != NULL);
5262               dyn.d_un.d_val = get_elf_backend_data (dynobj)->s->sizeof_rel;
5263               break;
5264
5265             case DT_STRSZ:
5266               /* Rewrite DT_STRSZ.  */
5267               dyn.d_un.d_val =
5268                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5269               break;
5270
5271             case DT_PLTGOT:
5272               name = ".got";
5273               goto get_vma;
5274             case DT_MIPS_CONFLICT:
5275               name = ".conflict";
5276               goto get_vma;
5277             case DT_MIPS_LIBLIST:
5278               name = ".liblist";
5279             get_vma:
5280               s = bfd_get_section_by_name (output_bfd, name);
5281               BFD_ASSERT (s != NULL);
5282               dyn.d_un.d_ptr = s->vma;
5283               break;
5284
5285             case DT_MIPS_RLD_VERSION:
5286               dyn.d_un.d_val = 1; /* XXX */
5287               break;
5288
5289             case DT_MIPS_FLAGS:
5290               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
5291               break;
5292
5293             case DT_MIPS_CONFLICTNO:
5294               name = ".conflict";
5295               elemsize = sizeof (Elf32_Conflict);
5296               goto set_elemno;
5297
5298             case DT_MIPS_LIBLISTNO:
5299               name = ".liblist";
5300               elemsize = sizeof (Elf32_Lib);
5301             set_elemno:
5302               s = bfd_get_section_by_name (output_bfd, name);
5303               if (s != NULL)
5304                 {
5305                   if (s->_cooked_size != 0)
5306                     dyn.d_un.d_val = s->_cooked_size / elemsize;
5307                   else
5308                     dyn.d_un.d_val = s->_raw_size / elemsize;
5309                 }
5310               else
5311                 dyn.d_un.d_val = 0;
5312               break;
5313
5314             case DT_MIPS_TIME_STAMP:
5315               time ((time_t *) &dyn.d_un.d_val);
5316               break;
5317
5318             case DT_MIPS_ICHECKSUM:
5319               /* XXX FIXME: */
5320               swap_out_p = false;
5321               break;
5322
5323             case DT_MIPS_IVERSION:
5324               /* XXX FIXME: */
5325               swap_out_p = false;
5326               break;
5327
5328             case DT_MIPS_BASE_ADDRESS:
5329               s = output_bfd->sections;
5330               BFD_ASSERT (s != NULL);
5331               dyn.d_un.d_ptr = s->vma & ~(0xffff);
5332               break;
5333
5334             case DT_MIPS_LOCAL_GOTNO:
5335               dyn.d_un.d_val = g->local_gotno;
5336               break;
5337
5338             case DT_MIPS_UNREFEXTNO:
5339               /* The index into the dynamic symbol table which is the
5340                  entry of the first external symbol that is not
5341                  referenced within the same object.  */
5342               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
5343               break;
5344
5345             case DT_MIPS_GOTSYM:
5346               if (g->global_gotsym)
5347                 {
5348                   dyn.d_un.d_val = g->global_gotsym->dynindx;
5349                   break;
5350                 }
5351               /* In case if we don't have global got symbols we default
5352                  to setting DT_MIPS_GOTSYM to the same value as
5353                  DT_MIPS_SYMTABNO, so we just fall through.  */
5354
5355             case DT_MIPS_SYMTABNO:
5356               name = ".dynsym";
5357               elemsize = get_elf_backend_data (output_bfd)->s->sizeof_sym;
5358               s = bfd_get_section_by_name (output_bfd, name);
5359               BFD_ASSERT (s != NULL);
5360
5361               if (s->_cooked_size != 0)
5362                 dyn.d_un.d_val = s->_cooked_size / elemsize;
5363               else
5364                 dyn.d_un.d_val = s->_raw_size / elemsize;
5365               break;
5366
5367             case DT_MIPS_HIPAGENO:
5368               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
5369               break;
5370
5371             case DT_MIPS_OPTIONS:
5372               s = bfd_get_section_by_name(output_bfd, ".MIPS.options");
5373               dyn.d_un.d_ptr = s->vma;
5374               break;
5375
5376             case DT_MIPS_MSYM:
5377               s = bfd_get_section_by_name(output_bfd, ".msym");
5378               dyn.d_un.d_ptr = s->vma;
5379               break;
5380
5381             default:
5382               swap_out_p = false;
5383               break;
5384             }
5385
5386           if (swap_out_p)
5387             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
5388               (dynobj, &dyn, b);
5389         }
5390     }
5391
5392   /* The first entry of the global offset table will be filled at
5393      runtime. The second entry will be used by some runtime loaders.
5394      This isn't the case of Irix rld.  */
5395   if (sgot != NULL && sgot->_raw_size > 0)
5396     {
5397       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
5398       bfd_put_64 (output_bfd, (bfd_vma) 0x80000000, sgot->contents + 8);
5399     }
5400
5401   if (sgot != NULL)
5402     elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
5403
5404   {
5405     asection *smsym;
5406     asection *s;
5407
5408     /* ??? The section symbols for the output sections were set up in
5409        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
5410        symbols.  Should we do so?  */
5411
5412     smsym = bfd_get_section_by_name (dynobj, ".msym");
5413     if (smsym != NULL)
5414       {
5415         Elf32_Internal_Msym msym;
5416
5417         msym.ms_hash_value = 0;
5418         msym.ms_info = ELF32_MS_INFO (0, 1);
5419
5420         for (s = output_bfd->sections; s != NULL; s = s->next)
5421           {
5422             long dynindx = elf_section_data (s)->dynindx;
5423
5424             mips_elf64_swap_msym_out
5425               (output_bfd, &msym,
5426                (((Elf32_External_Msym *) smsym->contents)
5427                 + dynindx));
5428           }
5429       }
5430
5431     /* Clean up a first relocation in .rel.dyn.  */
5432     s = bfd_get_section_by_name (dynobj, "rel.dyn");
5433     if (s != NULL && s->_raw_size > 0)
5434       memset (s->contents, 0, get_elf_backend_data (dynobj)->s->sizeof_rel);
5435   }
5436
5437   return true;
5438 }
5439
5440 /* Return the section that should be marked against GC for a given
5441    relocation.  */
5442
5443 asection *
5444 mips_elf64_gc_mark_hook (abfd, info, rel, h, sym)
5445      bfd *abfd;
5446      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5447      Elf_Internal_Rela *rel;
5448      struct elf_link_hash_entry *h;
5449      Elf_Internal_Sym *sym;
5450 {
5451   if (h != NULL)
5452     {
5453       switch (ELF64_R_TYPE (rel->r_info))
5454         {
5455         case R_MIPS_GNU_VTINHERIT:
5456         case R_MIPS_GNU_VTENTRY:
5457           break;
5458
5459         default:
5460           switch (h->root.type)
5461             {
5462             case bfd_link_hash_defined:
5463             case bfd_link_hash_defweak:
5464               return h->root.u.def.section;
5465
5466             case bfd_link_hash_common:
5467               return h->root.u.c.p->section;
5468
5469             default:
5470               break;
5471             }
5472         }
5473     }
5474   else
5475     {
5476       return bfd_section_from_elf_index (abfd, sym->st_shndx);
5477     }
5478
5479   return NULL;
5480 }
5481
5482 /* Update the got entry reference counts for the section being removed.  */
5483
5484 boolean
5485 mips_elf64_gc_sweep_hook (abfd, info, sec, relocs)
5486      bfd *abfd ATTRIBUTE_UNUSED;
5487      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5488      asection *sec ATTRIBUTE_UNUSED;
5489      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
5490 {
5491 #if 0
5492   Elf_Internal_Shdr *symtab_hdr;
5493   struct elf_link_hash_entry **sym_hashes;
5494   bfd_signed_vma *local_got_refcounts;
5495   const Elf_Internal_Rela *rel, *relend;
5496   unsigned long r_symndx;
5497   struct elf_link_hash_entry *h;
5498
5499   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5500   sym_hashes = elf_sym_hashes (abfd);
5501   local_got_refcounts = elf_local_got_refcounts (abfd);
5502
5503   relend = relocs + sec->reloc_count;
5504   for (rel = relocs; rel < relend; rel++)
5505     switch (ELF64_R_TYPE (rel->r_info))
5506       {
5507       case R_MIPS_GOT16:
5508       case R_MIPS_CALL16:
5509       case R_MIPS_CALL_HI16:
5510       case R_MIPS_CALL_LO16:
5511       case R_MIPS_GOT_HI16:
5512       case R_MIPS_GOT_LO16:
5513         /* ??? It would seem that the existing MIPS code does no sort
5514            of reference counting or whatnot on its GOT and PLT entries,
5515            so it is not possible to garbage collect them at this time.  */
5516         break;
5517
5518       default:
5519         break;
5520       }
5521 #endif
5522
5523   return true;
5524 }
5525 \f
5526 /* Create the .got section to hold the global offset table. */
5527
5528 static boolean
5529 mips_elf64_create_got_section (abfd, info)
5530      bfd *abfd;
5531      struct bfd_link_info *info;
5532 {
5533   flagword flags;
5534   register asection *s;
5535   struct elf_link_hash_entry *h;
5536   struct mips_elf64_got_info *g;
5537
5538   /* This function may be called more than once.  */
5539   if (bfd_get_section_by_name (abfd, ".got"))
5540     return true;
5541
5542   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5543            | SEC_LINKER_CREATED);
5544
5545   s = bfd_make_section (abfd, ".got");
5546   if (s == NULL
5547       || ! bfd_set_section_flags (abfd, s, flags)
5548       || ! bfd_set_section_alignment (abfd, s, 4))
5549     return false;
5550
5551   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
5552      linker script because we don't want to define the symbol if we
5553      are not creating a global offset table.  */
5554   h = NULL;
5555   if (! (_bfd_generic_link_add_one_symbol
5556          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5557           (bfd_vma) 0, (const char *) NULL, false,
5558           get_elf_backend_data (abfd)->collect,
5559           (struct bfd_link_hash_entry **) &h)))
5560     return false;
5561   h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
5562   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5563   h->type = STT_OBJECT;
5564
5565   if (info->shared
5566       && ! bfd_elf64_link_record_dynamic_symbol (info, h))
5567     return false;
5568
5569   /* The first several global offset table entries are reserved.  */
5570   s->_raw_size = MIPS_RESERVED_GOTNO * (get_elf_backend_data (abfd)->s->arch_size / 8);
5571
5572   g = (struct mips_elf64_got_info *) bfd_alloc (abfd,
5573                                           sizeof (struct mips_elf64_got_info));
5574   if (g == NULL)
5575     return false;
5576   g->global_gotsym = NULL;
5577   g->local_gotno = MIPS_RESERVED_GOTNO;
5578   g->assigned_gotno = MIPS_RESERVED_GOTNO;
5579   if (elf_section_data (s) == NULL)
5580     {
5581       s->used_by_bfd =
5582         (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
5583       if (elf_section_data (s) == NULL)
5584         return false;
5585     }
5586   elf_section_data (s)->tdata = (PTR) g;
5587   elf_section_data (s)->this_hdr.sh_flags
5588     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5589
5590   return true;
5591 }
5592
5593 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5594    symbol table index lower than any we've seen to date, record it for
5595    posterity.  */
5596
5597 static boolean
5598 mips_elf64_record_global_got_symbol (h, info, g)
5599      struct elf_link_hash_entry *h;
5600      struct bfd_link_info *info;
5601      struct mips_elf64_got_info *g ATTRIBUTE_UNUSED;
5602 {
5603   /* A global symbol in the GOT must also be in the dynamic symbol
5604      table.  */
5605   if (h->dynindx == -1
5606       && !bfd_elf64_link_record_dynamic_symbol (info, h))
5607     return false;
5608
5609   /* If we've already marked this entry as needing GOT space, we don't
5610      need to do it again.  */
5611   if (h->got.offset != (bfd_vma) - 1)
5612     return true;
5613
5614   /* By setting this to a value other than -1, we are indicating that
5615      there needs to be a GOT entry for H.  Avoid using zero, as the
5616      generic ELF copy_indirect_symbol tests for <= 0.  */
5617   h->got.offset = 1;
5618
5619   return true;
5620 }
5621
5622 /* Returns the .msym section for ABFD, creating it if it does not
5623    already exist.  Returns NULL to indicate error.  */
5624
5625 static asection *
5626 mips_elf64_create_msym_section (abfd)
5627      bfd *abfd;
5628 {
5629   asection *s;
5630
5631   s = bfd_get_section_by_name (abfd, ".msym");
5632   if (!s)
5633     {
5634       s = bfd_make_section (abfd, ".msym");
5635       if (!s
5636           || !bfd_set_section_flags (abfd, s,
5637                                      SEC_ALLOC
5638                                      | SEC_LOAD
5639                                      | SEC_HAS_CONTENTS
5640                                      | SEC_LINKER_CREATED
5641                                      | SEC_READONLY)
5642           || !bfd_set_section_alignment (abfd, s, 3))
5643         return NULL;
5644     }
5645
5646   return s;
5647 }
5648
5649 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
5650
5651 static void
5652 mips_elf64_allocate_dynamic_relocations (abfd, n)
5653      bfd *abfd;
5654      unsigned int n;
5655 {
5656   asection *s;
5657
5658   s = bfd_get_section_by_name (abfd, ".rel.dyn");
5659   BFD_ASSERT (s != NULL);
5660
5661   if (s->_raw_size == 0)
5662     {
5663       /* Make room for a null element. */
5664       s->_raw_size += get_elf_backend_data (abfd)->s->sizeof_rel;
5665       ++s->reloc_count;
5666     }
5667   s->_raw_size += n * get_elf_backend_data (abfd)->s->sizeof_rel;
5668 }
5669
5670 /* Look through the relocs for a section during the first phase, and
5671    allocate space in the global offset table.  */
5672
5673 boolean
5674 mips_elf64_check_relocs (abfd, info, sec, relocs)
5675      bfd *abfd;
5676      struct bfd_link_info *info;
5677      asection *sec;
5678      const Elf_Internal_Rela *relocs;
5679 {
5680   const char *name;
5681   bfd *dynobj;
5682   Elf_Internal_Shdr *symtab_hdr;
5683   struct elf_link_hash_entry **sym_hashes;
5684   struct mips_elf64_got_info *g;
5685   size_t extsymoff;
5686   const Elf_Internal_Rela *rel;
5687   const Elf_Internal_Rela *rel_end;
5688   asection *sgot;
5689   asection *sreloc;
5690   struct elf_backend_data *bed;
5691
5692   if (info->relocateable)
5693     return true;
5694
5695   dynobj = elf_hash_table (info)->dynobj;
5696   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5697   sym_hashes = elf_sym_hashes (abfd);
5698   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5699
5700   /* Check for the mips16 stub sections.  */
5701
5702   name = bfd_get_section_name (abfd, sec);
5703   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5704     {
5705       unsigned long r_symndx;
5706
5707       /* Look at the relocation information to figure out which symbol
5708          this is for.  */
5709
5710       r_symndx = ELF64_R_SYM (relocs->r_info);
5711
5712       if (r_symndx < extsymoff
5713           || sym_hashes[r_symndx - extsymoff] == NULL)
5714         {
5715           asection *o;
5716
5717           /* This stub is for a local symbol.  This stub will only be
5718              needed if there is some relocation in this BFD, other
5719              than a 16 bit function call, which refers to this symbol.  */
5720           for (o = abfd->sections; o != NULL; o = o->next)
5721             {
5722               Elf_Internal_Rela *sec_relocs;
5723               const Elf_Internal_Rela *r, *rend;
5724
5725               /* We can ignore stub sections when looking for relocs.  */
5726               if ((o->flags & SEC_RELOC) == 0
5727                   || o->reloc_count == 0
5728                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5729                               sizeof FN_STUB - 1) == 0
5730                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5731                               sizeof CALL_STUB - 1) == 0
5732                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5733                               sizeof CALL_FP_STUB - 1) == 0)
5734                 continue;
5735
5736               sec_relocs = (_bfd_elf64_link_read_relocs
5737                             (abfd, o, (PTR) NULL,
5738                              (Elf_Internal_Rela *) NULL,
5739                              info->keep_memory));
5740               if (sec_relocs == NULL)
5741                 return false;
5742
5743               rend = sec_relocs + o->reloc_count;
5744               for (r = sec_relocs; r < rend; r++)
5745                 if (ELF64_R_SYM (r->r_info) == r_symndx
5746                     && ELF64_R_TYPE (r->r_info) != R_MIPS16_26)
5747                   break;
5748
5749               if (! info->keep_memory)
5750                 free (sec_relocs);
5751
5752               if (r < rend)
5753                 break;
5754             }
5755
5756           if (o == NULL)
5757             {
5758               /* There is no non-call reloc for this stub, so we do
5759                  not need it.  Since this function is called before
5760                  the linker maps input sections to output sections, we
5761                  can easily discard it by setting the SEC_EXCLUDE
5762                  flag.  */
5763               sec->flags |= SEC_EXCLUDE;
5764               return true;
5765             }
5766
5767           /* Record this stub in an array of local symbol stubs for
5768              this BFD.  */
5769           if (elf_tdata (abfd)->local_stubs == NULL)
5770             {
5771               unsigned long symcount;
5772               asection **n;
5773               bfd_size_type amt;
5774
5775               if (elf_bad_symtab (abfd))
5776                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5777               else
5778                 symcount = symtab_hdr->sh_info;
5779               amt = symcount * sizeof (asection *);
5780               n = (asection **) bfd_zalloc (abfd, amt);
5781               if (n == NULL)
5782                 return false;
5783               elf_tdata (abfd)->local_stubs = n;
5784             }
5785
5786           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5787
5788           /* We don't need to set mips16_stubs_seen in this case.
5789              That flag is used to see whether we need to look through
5790              the global symbol table for stubs.  We don't need to set
5791              it here, because we just have a local stub.  */
5792         }
5793       else
5794         {
5795           struct mips_elf64_link_hash_entry *h;
5796
5797           h = ((struct mips_elf64_link_hash_entry *)
5798                sym_hashes[r_symndx - extsymoff]);
5799
5800           /* H is the symbol this stub is for.  */
5801
5802           h->fn_stub = sec;
5803           mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5804         }
5805     }
5806   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5807            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5808     {
5809       unsigned long r_symndx;
5810       struct mips_elf64_link_hash_entry *h;
5811       asection **loc;
5812
5813       /* Look at the relocation information to figure out which symbol
5814          this is for.  */
5815
5816       r_symndx = ELF64_R_SYM (relocs->r_info);
5817
5818       if (r_symndx < extsymoff
5819           || sym_hashes[r_symndx - extsymoff] == NULL)
5820         {
5821           /* This stub was actually built for a static symbol defined
5822              in the same file.  We assume that all static symbols in
5823              mips16 code are themselves mips16, so we can simply
5824              discard this stub.  Since this function is called before
5825              the linker maps input sections to output sections, we can
5826              easily discard it by setting the SEC_EXCLUDE flag.  */
5827           sec->flags |= SEC_EXCLUDE;
5828           return true;
5829         }
5830
5831       h = ((struct mips_elf64_link_hash_entry *)
5832            sym_hashes[r_symndx - extsymoff]);
5833
5834       /* H is the symbol this stub is for.  */
5835
5836       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5837         loc = &h->call_fp_stub;
5838       else
5839         loc = &h->call_stub;
5840
5841       /* If we already have an appropriate stub for this function, we
5842          don't need another one, so we can discard this one.  Since
5843          this function is called before the linker maps input sections
5844          to output sections, we can easily discard it by setting the
5845          SEC_EXCLUDE flag.  We can also discard this section if we
5846          happen to already know that this is a mips16 function; it is
5847          not necessary to check this here, as it is checked later, but
5848          it is slightly faster to check now.  */
5849       if (*loc != NULL || h->root.other == STO_MIPS16)
5850         {
5851           sec->flags |= SEC_EXCLUDE;
5852           return true;
5853         }
5854
5855       *loc = sec;
5856       mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5857     }
5858
5859   if (dynobj == NULL)
5860     {
5861       sgot = NULL;
5862       g = NULL;
5863     }
5864   else
5865     {
5866       sgot = bfd_get_section_by_name (dynobj, ".got");
5867       if (sgot == NULL)
5868         g = NULL;
5869       else
5870         {
5871           BFD_ASSERT (elf_section_data (sgot) != NULL);
5872           g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5873           BFD_ASSERT (g != NULL);
5874         }
5875     }
5876
5877   sreloc = NULL;
5878   bed = get_elf_backend_data (abfd);
5879   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5880   for (rel = relocs; rel < rel_end; ++rel)
5881     {
5882       unsigned long r_symndx;
5883       int r_type;
5884       struct elf_link_hash_entry *h;
5885
5886       r_symndx = ELF64_R_SYM (rel->r_info);
5887       r_type = ELF64_MIPS_R_TYPE (rel->r_info);
5888
5889       if (r_symndx < extsymoff)
5890         h = NULL;
5891       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5892         {
5893           (*_bfd_error_handler)
5894             (_("%s: Malformed reloc detected for section %s"),
5895              bfd_archive_filename (abfd), name);
5896           bfd_set_error (bfd_error_bad_value);
5897           return false;
5898         }
5899       else
5900         {
5901           h = sym_hashes[r_symndx - extsymoff];
5902
5903           /* This may be an indirect symbol created because of a version.  */
5904           if (h != NULL)
5905             {
5906               while (h->root.type == bfd_link_hash_indirect)
5907                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5908             }
5909         }
5910
5911       /* Some relocs require a global offset table.  */
5912       if (dynobj == NULL || sgot == NULL)
5913         {
5914           switch (r_type)
5915             {
5916             case R_MIPS_GOT16:
5917             case R_MIPS_CALL16:
5918             case R_MIPS_CALL_HI16:
5919             case R_MIPS_CALL_LO16:
5920             case R_MIPS_GOT_HI16:
5921             case R_MIPS_GOT_LO16:
5922             case R_MIPS_GOT_PAGE:
5923             case R_MIPS_GOT_OFST:
5924             case R_MIPS_GOT_DISP:
5925               if (dynobj == NULL)
5926                 elf_hash_table (info)->dynobj = dynobj = abfd;
5927               if (! mips_elf64_create_got_section (dynobj, info))
5928                 return false;
5929               g = _mips_elf64_got_info (dynobj, &sgot);
5930               break;
5931
5932             case R_MIPS_32:
5933             case R_MIPS_REL32:
5934             case R_MIPS_64:
5935               if (dynobj == NULL
5936                   && (info->shared || h != NULL)
5937                   && (sec->flags & SEC_ALLOC) != 0)
5938                 elf_hash_table (info)->dynobj = dynobj = abfd;
5939               break;
5940
5941             default:
5942               break;
5943             }
5944         }
5945
5946       if (!h && (r_type == R_MIPS_CALL_LO16
5947                  || r_type == R_MIPS_GOT_LO16
5948                  || r_type == R_MIPS_GOT_DISP))
5949         {
5950           /* We may need a local GOT entry for this relocation.  We
5951              don't count R_MIPS_GOT_PAGE because we can estimate the
5952              maximum number of pages needed by looking at the size of
5953              the segment.  Similar comments apply to R_MIPS_GOT16 and
5954              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5955              R_MIPS_CALL_HI16 because these are always followed by an
5956              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
5957
5958              This estimation is very conservative since we can merge
5959              duplicate entries in the GOT.  In order to be less
5960              conservative, we could actually build the GOT here,
5961              rather than in relocate_section.  */
5962           g->local_gotno++;
5963           sgot->_raw_size += get_elf_backend_data (dynobj)->s->arch_size / 8;
5964         }
5965
5966       switch (r_type)
5967         {
5968         case R_MIPS_CALL16:
5969           if (h == NULL)
5970             {
5971               (*_bfd_error_handler)
5972                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5973                  bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5974               bfd_set_error (bfd_error_bad_value);
5975               return false;
5976             }
5977           /* Fall through.  */
5978
5979         case R_MIPS_CALL_HI16:
5980         case R_MIPS_CALL_LO16:
5981           if (h != NULL)
5982             {
5983               /* This symbol requires a global offset table entry.  */
5984               if (!mips_elf64_record_global_got_symbol (h, info, g))
5985                 return false;
5986
5987               /* We need a stub, not a plt entry for the undefined
5988                  function.  But we record it as if it needs plt.  See
5989                  elf_adjust_dynamic_symbol in elflink.h.  */
5990               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5991               h->type = STT_FUNC;
5992             }
5993           break;
5994
5995         case R_MIPS_GOT16:
5996         case R_MIPS_GOT_HI16:
5997         case R_MIPS_GOT_LO16:
5998         case R_MIPS_GOT_DISP:
5999           /* This symbol requires a global offset table entry.  */
6000           if (h && !mips_elf64_record_global_got_symbol (h, info, g))
6001             return false;
6002           break;
6003
6004         case R_MIPS_32:
6005         case R_MIPS_REL32:
6006         case R_MIPS_64:
6007           if ((info->shared || h != NULL)
6008               && (sec->flags & SEC_ALLOC) != 0)
6009             {
6010               if (sreloc == NULL)
6011                 {
6012                   const char *name = ".rel.dyn";
6013
6014                   sreloc = bfd_get_section_by_name (dynobj, name);
6015                   if (sreloc == NULL)
6016                     {
6017                       sreloc = bfd_make_section (dynobj, name);
6018                       if (sreloc == NULL
6019                           || ! bfd_set_section_flags (dynobj, sreloc,
6020                                                       (SEC_ALLOC
6021                                                        | SEC_LOAD
6022                                                        | SEC_HAS_CONTENTS
6023                                                        | SEC_IN_MEMORY
6024                                                        | SEC_LINKER_CREATED
6025                                                        | SEC_READONLY))
6026                           || ! bfd_set_section_alignment (dynobj, sreloc,
6027                                                           4))
6028                         return false;
6029                     }
6030                 }
6031 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
6032               if (info->shared)
6033                 {
6034                   /* When creating a shared object, we must copy these
6035                      reloc types into the output file as R_MIPS_REL32
6036                      relocs.  We make room for this reloc in the
6037                      .rel.dyn reloc section.  */
6038                   mips_elf64_allocate_dynamic_relocations (dynobj, 1);
6039                   if ((sec->flags & MIPS_READONLY_SECTION)
6040                       == MIPS_READONLY_SECTION)
6041                     /* We tell the dynamic linker that there are
6042                        relocations against the text segment.  */
6043                     info->flags |= DF_TEXTREL;
6044                 }
6045               else
6046                 {
6047                   struct mips_elf64_link_hash_entry *hmips;
6048
6049                   /* We only need to copy this reloc if the symbol is
6050                      defined in a dynamic object.  */
6051                   hmips = (struct mips_elf64_link_hash_entry *) h;
6052                   ++hmips->possibly_dynamic_relocs;
6053                   if ((sec->flags & MIPS_READONLY_SECTION)
6054                       == MIPS_READONLY_SECTION)
6055                     /* We need it to tell the dynamic linker if there
6056                        are relocations against the text segment.  */
6057                     hmips->readonly_reloc = true;
6058                 }
6059
6060               /* Even though we don't directly need a GOT entry for
6061                  this symbol, a symbol must have a dynamic symbol
6062                  table index greater that DT_MIPS_GOTSYM if there are
6063                  dynamic relocations against it.  */
6064               if (h != NULL
6065                   && !mips_elf64_record_global_got_symbol (h, info, g))
6066                 return false;
6067             }
6068           break;
6069
6070         case R_MIPS_26:
6071         case R_MIPS_GPREL16:
6072         case R_MIPS_LITERAL:
6073         case R_MIPS_GPREL32:
6074           break;
6075
6076           /* This relocation describes the C++ object vtable hierarchy.
6077              Reconstruct it for later use during GC.  */
6078         case R_MIPS_GNU_VTINHERIT:
6079           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6080             return false;
6081           break;
6082
6083           /* This relocation describes which C++ vtable entries are actually
6084              used.  Record for later use during GC.  */
6085         case R_MIPS_GNU_VTENTRY:
6086           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6087             return false;
6088           break;
6089
6090         default:
6091           break;
6092         }
6093     }
6094
6095   return true;
6096 }
6097
6098 /* Structure used to pass information to mips_elf64_output_extsym.  */
6099
6100 struct extsym_info
6101 {
6102   bfd *abfd;
6103   struct bfd_link_info *info;
6104   struct ecoff_debug_info *debug;
6105   const struct ecoff_debug_swap *swap;
6106   boolean failed;
6107 };
6108
6109 /* This routine is used to write out ECOFF debugging external symbol
6110    information.  It is called via mips_elf64_link_hash_traverse.  The
6111    ECOFF external symbol information must match the ELF external
6112    symbol information.  Unfortunately, at this point we don't know
6113    whether a symbol is required by reloc information, so the two
6114    tables may wind up being different.  We must sort out the external
6115    symbol information before we can set the final size of the .mdebug
6116    section, and we must set the size of the .mdebug section before we
6117    can relocate any sections, and we can't know which symbols are
6118    required by relocation until we relocate the sections.
6119    Fortunately, it is relatively unlikely that any symbol will be
6120    stripped but required by a reloc.  In particular, it can not happen
6121    when generating a final executable.  */
6122
6123 static boolean
6124 mips_elf64_output_extsym (h, data)
6125      struct mips_elf64_link_hash_entry *h;
6126      PTR data;
6127 {
6128   struct extsym_info *einfo = (struct extsym_info *) data;
6129   boolean strip;
6130   asection *sec, *output_section;
6131
6132   if (h->root.indx == -2)
6133     strip = false;
6134   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
6135             || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
6136            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
6137            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
6138     strip = true;
6139   else if (einfo->info->strip == strip_all
6140            || (einfo->info->strip == strip_some
6141                && bfd_hash_lookup (einfo->info->keep_hash,
6142                                    h->root.root.root.string,
6143                                    false, false) == NULL))
6144     strip = true;
6145   else
6146     strip = false;
6147
6148   if (strip)
6149     return true;
6150
6151   if (h->esym.ifd == -2)
6152     {
6153       h->esym.jmptbl = 0;
6154       h->esym.cobol_main = 0;
6155       h->esym.weakext = 0;
6156       h->esym.reserved = 0;
6157       h->esym.ifd = ifdNil;
6158       h->esym.asym.value = 0;
6159       h->esym.asym.st = stGlobal;
6160
6161       if (h->root.root.type == bfd_link_hash_undefined
6162               || h->root.root.type == bfd_link_hash_undefweak)
6163         {
6164           const char *name;
6165
6166           /* Use undefined class.  Also, set class and type for some
6167              special symbols.  */
6168           name = h->root.root.root.string;
6169           h->esym.asym.sc = scUndefined;
6170         }
6171       else if (h->root.root.type != bfd_link_hash_defined
6172           && h->root.root.type != bfd_link_hash_defweak)
6173         h->esym.asym.sc = scAbs;
6174       else
6175         {
6176           const char *name;
6177
6178           sec = h->root.root.u.def.section;
6179           output_section = sec->output_section;
6180
6181           /* When making a shared library and symbol h is the one from
6182              the another shared library, OUTPUT_SECTION may be null.  */
6183           if (output_section == NULL)
6184             h->esym.asym.sc = scUndefined;
6185           else
6186             {
6187               name = bfd_section_name (output_section->owner, output_section);
6188
6189               if (strcmp (name, ".text") == 0)
6190                 h->esym.asym.sc = scText;
6191               else if (strcmp (name, ".data") == 0)
6192                 h->esym.asym.sc = scData;
6193               else if (strcmp (name, ".sdata") == 0)
6194                 h->esym.asym.sc = scSData;
6195               else if (strcmp (name, ".rodata") == 0
6196                        || strcmp (name, ".rdata") == 0)
6197                 h->esym.asym.sc = scRData;
6198               else if (strcmp (name, ".bss") == 0)
6199                 h->esym.asym.sc = scBss;
6200               else if (strcmp (name, ".sbss") == 0)
6201                 h->esym.asym.sc = scSBss;
6202               else if (strcmp (name, ".init") == 0)
6203                 h->esym.asym.sc = scInit;
6204               else if (strcmp (name, ".fini") == 0)
6205                 h->esym.asym.sc = scFini;
6206               else
6207                 h->esym.asym.sc = scAbs;
6208             }
6209         }
6210
6211       h->esym.asym.reserved = 0;
6212       h->esym.asym.index = indexNil;
6213     }
6214
6215   if (h->root.root.type == bfd_link_hash_common)
6216     h->esym.asym.value = h->root.root.u.c.size;
6217   else if (h->root.root.type == bfd_link_hash_defined
6218            || h->root.root.type == bfd_link_hash_defweak)
6219     {
6220       if (h->esym.asym.sc == scCommon)
6221         h->esym.asym.sc = scBss;
6222       else if (h->esym.asym.sc == scSCommon)
6223         h->esym.asym.sc = scSBss;
6224
6225       sec = h->root.root.u.def.section;
6226       output_section = sec->output_section;
6227       if (output_section != NULL)
6228         h->esym.asym.value = (h->root.root.u.def.value
6229                               + sec->output_offset
6230                               + output_section->vma);
6231       else
6232         h->esym.asym.value = 0;
6233     }
6234   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
6235     {
6236       struct mips_elf64_link_hash_entry *hd = h;
6237       boolean no_fn_stub = h->no_fn_stub;
6238
6239       while (hd->root.root.type == bfd_link_hash_indirect)
6240         {
6241           hd = (struct mips_elf64_link_hash_entry *)h->root.root.u.i.link;
6242           no_fn_stub = no_fn_stub || hd->no_fn_stub;
6243         }
6244
6245       if (!no_fn_stub)
6246         {
6247           /* Set type and value for a symbol with a function stub.  */
6248           h->esym.asym.st = stProc;
6249           sec = hd->root.root.u.def.section;
6250           if (sec == NULL)
6251             h->esym.asym.value = 0;
6252           else
6253             {
6254               output_section = sec->output_section;
6255               if (output_section != NULL)
6256                 h->esym.asym.value = (hd->root.plt.offset
6257                                       + sec->output_offset
6258                                       + output_section->vma);
6259               else
6260                 h->esym.asym.value = 0;
6261             }
6262 #if 0 /* FIXME?  */
6263           h->esym.ifd = 0;
6264 #endif
6265         }
6266     }
6267
6268   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
6269                                       h->root.root.root.string,
6270                                       &h->esym))
6271     {
6272       einfo->failed = true;
6273       return false;
6274     }
6275
6276   return true;
6277 }
6278
6279 /* Swap an entry in a .gptab section.  Note that these routines rely
6280    on the equivalence of the two elements of the union.  */
6281
6282 static void
6283 mips_elf64_swap_gptab_in (abfd, ex, in)
6284      bfd *abfd;
6285      const Elf32_External_gptab *ex;
6286      Elf32_gptab *in;
6287 {
6288   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
6289   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
6290 }
6291
6292 static void
6293 mips_elf64_swap_gptab_out (abfd, in, ex)
6294      bfd *abfd;
6295      const Elf32_gptab *in;
6296      Elf32_External_gptab *ex;
6297 {
6298   H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
6299                 ex->gt_entry.gt_g_value);
6300   H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
6301                 ex->gt_entry.gt_bytes);
6302 }
6303
6304 /* A comparison routine used to sort .gptab entries.  */
6305
6306 static int
6307 gptab_compare (p1, p2)
6308      const PTR p1;
6309      const PTR p2;
6310 {
6311   const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
6312   const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
6313
6314   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
6315 }
6316
6317 /* We need to use a special link routine to handle the .mdebug section.
6318    We need to merge all instances of this section together, not write
6319    them all out sequentially.  */
6320
6321 boolean
6322 mips_elf64_final_link (abfd, info)
6323      bfd *abfd;
6324      struct bfd_link_info *info;
6325 {
6326   asection **secpp;
6327   asection *o;
6328   struct bfd_link_order *p;
6329   asection *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
6330   struct ecoff_debug_info debug;
6331   const struct ecoff_debug_swap *swap
6332     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
6333   HDRR *symhdr = &debug.symbolic_header;
6334   PTR mdebug_handle = NULL;
6335   asection *s;
6336   EXTR esym;
6337   unsigned int i;
6338   static const char * const secname[] =
6339       { ".text", ".init", ".fini", ".data",
6340           ".rodata", ".sdata", ".sbss", ".bss" };
6341   static const int sc[] = { scText, scInit, scFini, scData,
6342                           scRData, scSData, scSBss, scBss };
6343
6344   /* If all the things we linked together were PIC, but we're
6345      producing an executable (rather than a shared object), then the
6346      resulting file is CPIC (i.e., it calls PIC code.)  */
6347   if (!info->shared
6348       && !info->relocateable
6349       && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
6350     {
6351       elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
6352       elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
6353     }
6354
6355   /* We'd carefully arranged the dynamic symbol indices, and then the
6356      generic size_dynamic_sections renumbered them out from under us.
6357      Rather than trying somehow to prevent the renumbering, just do
6358      the sort again.  */
6359   if (elf_hash_table (info)->dynamic_sections_created)
6360     {
6361       bfd *dynobj;
6362       asection *got;
6363       struct mips_elf64_got_info *g;
6364
6365       /* When we resort, we must tell mips_elf64_sort_hash_table what
6366          the lowest index it may use is.  That's the number of section
6367          symbols we're going to add.  The generic ELF linker only
6368          adds these symbols when building a shared object.  Note that
6369          we count the sections after (possibly) removing the .options
6370          section above.  */
6371       if (!mips_elf64_sort_hash_table (info, (info->shared
6372                                             ? bfd_count_sections (abfd) + 1
6373                                             : 1)))
6374         return false;
6375
6376       /* Make sure we didn't grow the global .got region.  */
6377       dynobj = elf_hash_table (info)->dynobj;
6378       got = bfd_get_section_by_name (dynobj, ".got");
6379       g = (struct mips_elf64_got_info *) elf_section_data (got)->tdata;
6380
6381       if (g->global_gotsym != NULL)
6382         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
6383                      - g->global_gotsym->dynindx)
6384                     <= g->global_gotno);
6385     }
6386
6387   /* We include .MIPS.options, even though we don't process it quite right.
6388      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
6389      to be better off including it than not.  */
6390   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
6391     {
6392       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
6393         {
6394           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
6395             if (p->type == bfd_indirect_link_order)
6396               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
6397           (*secpp)->link_order_head = NULL;
6398           bfd_section_list_remove (abfd, secpp);
6399           --abfd->section_count;
6400
6401           break;
6402         }
6403     }
6404
6405   /* Get a value for the GP register.  */
6406   if (elf_gp (abfd) == 0)
6407     {
6408       struct bfd_link_hash_entry *h;
6409
6410       h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
6411       if (h != (struct bfd_link_hash_entry *) NULL
6412           && h->type == bfd_link_hash_defined)
6413         elf_gp (abfd) = (h->u.def.value
6414                          + h->u.def.section->output_section->vma
6415                          + h->u.def.section->output_offset);
6416       else if (info->relocateable)
6417         {
6418           bfd_vma lo = MINUS_ONE;
6419
6420           /* Find the GP-relative section with the lowest offset.  */
6421           for (o = abfd->sections; o != NULL; o = o->next)
6422             if (o->vma < lo
6423                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
6424               lo = o->vma;
6425
6426           /* And calculate GP relative to that.  */
6427           elf_gp (abfd) = (lo + 0x7ff0);
6428         }
6429       else
6430         {
6431           /* If the relocate_section function needs to do a reloc
6432              involving the GP value, it should make a reloc_dangerous
6433              callback to warn that GP is not defined.  */
6434         }
6435     }
6436
6437   /* Go through the sections and collect the .mdebug information.  */
6438   mdebug_sec = NULL;
6439   gptab_data_sec = NULL;
6440   gptab_bss_sec = NULL;
6441   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
6442     {
6443       if (strcmp (o->name, ".mdebug") == 0)
6444         {
6445           struct extsym_info einfo;
6446           bfd_vma last;
6447
6448           /* We have found the .mdebug section in the output file.
6449              Look through all the link_orders comprising it and merge
6450              the information together.  */
6451           symhdr->magic = swap->sym_magic;
6452           /* FIXME: What should the version stamp be?  */
6453           symhdr->vstamp = 0;
6454           symhdr->ilineMax = 0;
6455           symhdr->cbLine = 0;
6456           symhdr->idnMax = 0;
6457           symhdr->ipdMax = 0;
6458           symhdr->isymMax = 0;
6459           symhdr->ioptMax = 0;
6460           symhdr->iauxMax = 0;
6461           symhdr->issMax = 0;
6462           symhdr->issExtMax = 0;
6463           symhdr->ifdMax = 0;
6464           symhdr->crfd = 0;
6465           symhdr->iextMax = 0;
6466
6467           /* We accumulate the debugging information itself in the
6468              debug_info structure.  */
6469           debug.line = NULL;
6470           debug.external_dnr = NULL;
6471           debug.external_pdr = NULL;
6472           debug.external_sym = NULL;
6473           debug.external_opt = NULL;
6474           debug.external_aux = NULL;
6475           debug.ss = NULL;
6476           debug.ssext = debug.ssext_end = NULL;
6477           debug.external_fdr = NULL;
6478           debug.external_rfd = NULL;
6479           debug.external_ext = debug.external_ext_end = NULL;
6480
6481           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
6482           if (mdebug_handle == (PTR) NULL)
6483             return false;
6484
6485           esym.jmptbl = 0;
6486           esym.cobol_main = 0;
6487           esym.weakext = 0;
6488           esym.reserved = 0;
6489           esym.ifd = ifdNil;
6490           esym.asym.iss = issNil;
6491           esym.asym.st = stLocal;
6492           esym.asym.reserved = 0;
6493           esym.asym.index = indexNil;
6494           last = 0;
6495           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
6496             {
6497               esym.asym.sc = sc[i];
6498               s = bfd_get_section_by_name (abfd, secname[i]);
6499               if (s != NULL)
6500                 {
6501                   esym.asym.value = s->vma;
6502                   last = s->vma + s->_raw_size;
6503                 }
6504               else
6505                 esym.asym.value = last;
6506               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
6507                                                  secname[i], &esym))
6508                 return false;
6509             }
6510
6511           for (p = o->link_order_head;
6512                p != (struct bfd_link_order *) NULL;
6513                p = p->next)
6514             {
6515               asection *input_section;
6516               bfd *input_bfd;
6517               const struct ecoff_debug_swap *input_swap;
6518               struct ecoff_debug_info input_debug;
6519               char *eraw_src;
6520               char *eraw_end;
6521
6522               if (p->type != bfd_indirect_link_order)
6523                 {
6524                   if (p->type == bfd_data_link_order)
6525                     continue;
6526                   abort ();
6527                 }
6528
6529               input_section = p->u.indirect.section;
6530               input_bfd = input_section->owner;
6531
6532               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
6533                   || (get_elf_backend_data (input_bfd)
6534                       ->elf_backend_ecoff_debug_swap) == NULL)
6535                 {
6536                   /* I don't know what a non MIPS ELF bfd would be
6537                      doing with a .mdebug section, but I don't really
6538                      want to deal with it.  */
6539                   continue;
6540                 }
6541
6542               input_swap = (get_elf_backend_data (input_bfd)
6543                             ->elf_backend_ecoff_debug_swap);
6544
6545               BFD_ASSERT (p->size == input_section->_raw_size);
6546
6547               /* The ECOFF linking code expects that we have already
6548                  read in the debugging information and set up an
6549                  ecoff_debug_info structure, so we do that now.  */
6550               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
6551                                                    &input_debug))
6552                 return false;
6553
6554               if (! (bfd_ecoff_debug_accumulate
6555                      (mdebug_handle, abfd, &debug, swap, input_bfd,
6556                       &input_debug, input_swap, info)))
6557                 return false;
6558
6559               /* Loop through the external symbols.  For each one with
6560                  interesting information, try to find the symbol in
6561                  the linker global hash table and save the information
6562                  for the output external symbols.  */
6563               eraw_src = input_debug.external_ext;
6564               eraw_end = (eraw_src
6565                           + (input_debug.symbolic_header.iextMax
6566                              * input_swap->external_ext_size));
6567               for (;
6568                    eraw_src < eraw_end;
6569                    eraw_src += input_swap->external_ext_size)
6570                 {
6571                   EXTR ext;
6572                   const char *name;
6573                   struct mips_elf64_link_hash_entry *h;
6574
6575                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
6576                   if (ext.asym.sc == scNil
6577                       || ext.asym.sc == scUndefined
6578                       || ext.asym.sc == scSUndefined)
6579                     continue;
6580
6581                   name = input_debug.ssext + ext.asym.iss;
6582                   h = mips_elf64_link_hash_lookup (mips_elf64_hash_table (info),
6583                                                  name, false, false, true);
6584                   if (h == NULL || h->esym.ifd != -2)
6585                     continue;
6586
6587                   if (ext.ifd != -1)
6588                     {
6589                       BFD_ASSERT (ext.ifd
6590                                   < input_debug.symbolic_header.ifdMax);
6591                       ext.ifd = input_debug.ifdmap[ext.ifd];
6592                     }
6593
6594                   h->esym = ext;
6595                 }
6596
6597               /* Free up the information we just read.  */
6598               free (input_debug.line);
6599               free (input_debug.external_dnr);
6600               free (input_debug.external_pdr);
6601               free (input_debug.external_sym);
6602               free (input_debug.external_opt);
6603               free (input_debug.external_aux);
6604               free (input_debug.ss);
6605               free (input_debug.ssext);
6606               free (input_debug.external_fdr);
6607               free (input_debug.external_rfd);
6608               free (input_debug.external_ext);
6609
6610               /* Hack: reset the SEC_HAS_CONTENTS flag so that
6611                  elf_link_input_bfd ignores this section.  */
6612               input_section->flags &=~ SEC_HAS_CONTENTS;
6613             }
6614
6615           /* Build the external symbol information.  */
6616           einfo.abfd = abfd;
6617           einfo.info = info;
6618           einfo.debug = &debug;
6619           einfo.swap = swap;
6620           einfo.failed = false;
6621           mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
6622                                        mips_elf64_output_extsym,
6623                                        (PTR) &einfo);
6624           if (einfo.failed)
6625             return false;
6626
6627           /* Set the size of the .mdebug section.  */
6628           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
6629
6630           /* Skip this section later on (I don't think this currently
6631              matters, but someday it might).  */
6632           o->link_order_head = (struct bfd_link_order *) NULL;
6633
6634           mdebug_sec = o;
6635         }
6636
6637       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
6638         {
6639           const char *subname;
6640           unsigned int c;
6641           Elf32_gptab *tab;
6642           Elf32_External_gptab *ext_tab;
6643           unsigned int i;
6644
6645           /* The .gptab.sdata and .gptab.sbss sections hold
6646              information describing how the small data area would
6647              change depending upon the -G switch.  These sections
6648              not used in executables files.  */
6649           if (! info->relocateable)
6650             {
6651               asection **secpp;
6652
6653               for (p = o->link_order_head;
6654                    p != (struct bfd_link_order *) NULL;
6655                    p = p->next)
6656                 {
6657                   asection *input_section;
6658
6659                   if (p->type != bfd_indirect_link_order)
6660                     {
6661                       if (p->type == bfd_data_link_order)
6662                         continue;
6663                       abort ();
6664                     }
6665
6666                   input_section = p->u.indirect.section;
6667
6668                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
6669                      elf_link_input_bfd ignores this section.  */
6670                   input_section->flags &=~ SEC_HAS_CONTENTS;
6671                 }
6672
6673               /* Skip this section later on (I don't think this
6674                  currently matters, but someday it might).  */
6675               o->link_order_head = (struct bfd_link_order *) NULL;
6676
6677               /* Really remove the section.  */
6678               for (secpp = &abfd->sections;
6679                    *secpp != o;
6680                    secpp = &(*secpp)->next)
6681                 ;
6682               bfd_section_list_remove (abfd, secpp);
6683               --abfd->section_count;
6684
6685               continue;
6686             }
6687
6688           /* There is one gptab for initialized data, and one for
6689              uninitialized data.  */
6690           if (strcmp (o->name, ".gptab.sdata") == 0)
6691             gptab_data_sec = o;
6692           else if (strcmp (o->name, ".gptab.sbss") == 0)
6693             gptab_bss_sec = o;
6694           else
6695             {
6696               (*_bfd_error_handler)
6697                 (_("%s: illegal section name `%s'"),
6698                  bfd_archive_filename (abfd), o->name);
6699               bfd_set_error (bfd_error_nonrepresentable_section);
6700               return false;
6701             }
6702
6703           /* The linker script always combines .gptab.data and
6704              .gptab.sdata into .gptab.sdata, and likewise for
6705              .gptab.bss and .gptab.sbss.  It is possible that there is
6706              no .sdata or .sbss section in the output file, in which
6707              case we must change the name of the output section.  */
6708           subname = o->name + sizeof ".gptab" - 1;
6709           if (bfd_get_section_by_name (abfd, subname) == NULL)
6710             {
6711               if (o == gptab_data_sec)
6712                 o->name = ".gptab.data";
6713               else
6714                 o->name = ".gptab.bss";
6715               subname = o->name + sizeof ".gptab" - 1;
6716               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
6717             }
6718
6719           /* Set up the first entry.  */
6720           c = 1;
6721           tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
6722           if (tab == NULL)
6723             return false;
6724           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
6725           tab[0].gt_header.gt_unused = 0;
6726
6727           /* Combine the input sections.  */
6728           for (p = o->link_order_head;
6729                p != (struct bfd_link_order *) NULL;
6730                p = p->next)
6731             {
6732               asection *input_section;
6733               bfd *input_bfd;
6734               bfd_size_type size;
6735               unsigned long last;
6736               bfd_size_type gpentry;
6737
6738               if (p->type != bfd_indirect_link_order)
6739                 {
6740                   if (p->type == bfd_data_link_order)
6741                     continue;
6742                   abort ();
6743                 }
6744
6745               input_section = p->u.indirect.section;
6746               input_bfd = input_section->owner;
6747
6748               /* Combine the gptab entries for this input section one
6749                  by one.  We know that the input gptab entries are
6750                  sorted by ascending -G value.  */
6751               size = bfd_section_size (input_bfd, input_section);
6752               last = 0;
6753               for (gpentry = sizeof (Elf32_External_gptab);
6754                    gpentry < size;
6755                    gpentry += sizeof (Elf32_External_gptab))
6756                 {
6757                   Elf32_External_gptab ext_gptab;
6758                   Elf32_gptab int_gptab;
6759                   unsigned long val;
6760                   unsigned long add;
6761                   boolean exact;
6762                   unsigned int look;
6763
6764                   if (! (bfd_get_section_contents
6765                          (input_bfd, input_section, (PTR) &ext_gptab,
6766                           gpentry, sizeof (Elf32_External_gptab))))
6767                     {
6768                       free (tab);
6769                       return false;
6770                     }
6771
6772                   mips_elf64_swap_gptab_in (input_bfd, &ext_gptab,
6773                                                 &int_gptab);
6774                   val = int_gptab.gt_entry.gt_g_value;
6775                   add = int_gptab.gt_entry.gt_bytes - last;
6776
6777                   exact = false;
6778                   for (look = 1; look < c; look++)
6779                     {
6780                       if (tab[look].gt_entry.gt_g_value >= val)
6781                         tab[look].gt_entry.gt_bytes += add;
6782
6783                       if (tab[look].gt_entry.gt_g_value == val)
6784                         exact = true;
6785                     }
6786
6787                   if (! exact)
6788                     {
6789                       Elf32_gptab *new_tab;
6790                       unsigned int max;
6791
6792                       /* We need a new table entry.  */
6793                       new_tab = ((Elf32_gptab *)
6794                                  bfd_realloc ((PTR) tab,
6795                                               (c + 1) * sizeof (Elf32_gptab)));
6796                       if (new_tab == NULL)
6797                         {
6798                           free (tab);
6799                           return false;
6800                         }
6801                       tab = new_tab;
6802                       tab[c].gt_entry.gt_g_value = val;
6803                       tab[c].gt_entry.gt_bytes = add;
6804
6805                       /* Merge in the size for the next smallest -G
6806                          value, since that will be implied by this new
6807                          value.  */
6808                       max = 0;
6809                       for (look = 1; look < c; look++)
6810                         {
6811                           if (tab[look].gt_entry.gt_g_value < val
6812                               && (max == 0
6813                                   || (tab[look].gt_entry.gt_g_value
6814                                       > tab[max].gt_entry.gt_g_value)))
6815                             max = look;
6816                         }
6817                       if (max != 0)
6818                         tab[c].gt_entry.gt_bytes +=
6819                           tab[max].gt_entry.gt_bytes;
6820
6821                       ++c;
6822                     }
6823
6824                   last = int_gptab.gt_entry.gt_bytes;
6825                 }
6826
6827               /* Hack: reset the SEC_HAS_CONTENTS flag so that
6828                  elf_link_input_bfd ignores this section.  */
6829               input_section->flags &=~ SEC_HAS_CONTENTS;
6830             }
6831
6832           /* The table must be sorted by -G value.  */
6833           if (c > 2)
6834             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
6835
6836           /* Swap out the table.  */
6837           ext_tab = ((Elf32_External_gptab *)
6838                      bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
6839           if (ext_tab == NULL)
6840             {
6841               free (tab);
6842               return false;
6843             }
6844
6845           for (i = 0; i < c; i++)
6846             mips_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
6847           free (tab);
6848
6849           o->_raw_size = c * sizeof (Elf32_External_gptab);
6850           o->contents = (bfd_byte *) ext_tab;
6851
6852           /* Skip this section later on (I don't think this currently
6853              matters, but someday it might).  */
6854           o->link_order_head = (struct bfd_link_order *) NULL;
6855         }
6856     }
6857
6858   /* Invoke the regular ELF backend linker to do all the work.  */
6859   if (!bfd_elf64_bfd_final_link (abfd, info))
6860      return false;
6861
6862   /* Now write out the computed sections.  */
6863   if (mdebug_sec != (asection *) NULL)
6864     {
6865       BFD_ASSERT (abfd->output_has_begun);
6866       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
6867                                                swap, info,
6868                                                mdebug_sec->filepos))
6869         return false;
6870
6871       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
6872     }
6873   if (gptab_data_sec != (asection *) NULL)
6874     {
6875       if (! bfd_set_section_contents (abfd, gptab_data_sec,
6876                                       gptab_data_sec->contents,
6877                                       (file_ptr) 0,
6878                                       gptab_data_sec->_raw_size))
6879         return false;
6880     }
6881
6882   if (gptab_bss_sec != (asection *) NULL)
6883     {
6884       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
6885                                       gptab_bss_sec->contents,
6886                                       (file_ptr) 0,
6887                                       gptab_bss_sec->_raw_size))
6888         return false;
6889     }
6890
6891   return true;
6892 }
6893 \f
6894 /* ECOFF swapping routines.  These are used when dealing with the
6895    .mdebug section, which is in the ECOFF debugging format.  */
6896 static const struct ecoff_debug_swap mips_elf64_ecoff_debug_swap =
6897 {
6898   /* Symbol table magic number.  */
6899   magicSym2,
6900   /* Alignment of debugging information.  E.g., 4.  */
6901   8,
6902   /* Sizes of external symbolic information.  */
6903   sizeof (struct hdr_ext),
6904   sizeof (struct dnr_ext),
6905   sizeof (struct pdr_ext),
6906   sizeof (struct sym_ext),
6907   sizeof (struct opt_ext),
6908   sizeof (struct fdr_ext),
6909   sizeof (struct rfd_ext),
6910   sizeof (struct ext_ext),
6911   /* Functions to swap in external symbolic data.  */
6912   ecoff_swap_hdr_in,
6913   ecoff_swap_dnr_in,
6914   ecoff_swap_pdr_in,
6915   ecoff_swap_sym_in,
6916   ecoff_swap_opt_in,
6917   ecoff_swap_fdr_in,
6918   ecoff_swap_rfd_in,
6919   ecoff_swap_ext_in,
6920   _bfd_ecoff_swap_tir_in,
6921   _bfd_ecoff_swap_rndx_in,
6922   /* Functions to swap out external symbolic data.  */
6923   ecoff_swap_hdr_out,
6924   ecoff_swap_dnr_out,
6925   ecoff_swap_pdr_out,
6926   ecoff_swap_sym_out,
6927   ecoff_swap_opt_out,
6928   ecoff_swap_fdr_out,
6929   ecoff_swap_rfd_out,
6930   ecoff_swap_ext_out,
6931   _bfd_ecoff_swap_tir_out,
6932   _bfd_ecoff_swap_rndx_out,
6933   /* Function to read in symbolic data.  */
6934   _bfd_mips_elf_read_ecoff_info
6935 };
6936 \f
6937 /* Relocations in the 64 bit MIPS ELF ABI are more complex than in
6938    standard ELF.  This structure is used to redirect the relocation
6939    handling routines.  */
6940
6941 const struct elf_size_info mips_elf64_size_info =
6942 {
6943   sizeof (Elf64_External_Ehdr),
6944   sizeof (Elf64_External_Phdr),
6945   sizeof (Elf64_External_Shdr),
6946   sizeof (Elf64_Mips_External_Rel),
6947   sizeof (Elf64_Mips_External_Rela),
6948   sizeof (Elf64_External_Sym),
6949   sizeof (Elf64_External_Dyn),
6950   sizeof (Elf_External_Note),
6951   4,            /* hash-table entry size */
6952   3,            /* internal relocations per external relocations */
6953   64,           /* arch_size */
6954   8,            /* file_align */
6955   ELFCLASS64,
6956   EV_CURRENT,
6957   bfd_elf64_write_out_phdrs,
6958   bfd_elf64_write_shdrs_and_ehdr,
6959   mips_elf64_write_relocs,
6960   bfd_elf64_swap_symbol_out,
6961   mips_elf64_slurp_reloc_table,
6962   bfd_elf64_slurp_symbol_table,
6963   bfd_elf64_swap_dyn_in,
6964   bfd_elf64_swap_dyn_out,
6965   mips_elf64_be_swap_reloc_in,
6966   mips_elf64_be_swap_reloc_out,
6967   mips_elf64_be_swap_reloca_in,
6968   mips_elf64_be_swap_reloca_out
6969 };
6970
6971 #define ELF_ARCH                        bfd_arch_mips
6972 #define ELF_MACHINE_CODE                EM_MIPS
6973
6974 #define ELF_MAXPAGESIZE                 0x1000
6975
6976 #define elf_backend_collect             true
6977 #define elf_backend_type_change_ok      true
6978 #define elf_backend_can_gc_sections     true
6979 #define elf_info_to_howto               mips_elf64_info_to_howto_rela
6980 #define elf_info_to_howto_rel           mips_elf64_info_to_howto_rel
6981 #define elf_backend_object_p            _bfd_mips_elf_object_p
6982 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
6983 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
6984 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
6985 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
6986 #define elf_backend_section_from_bfd_section \
6987                                         _bfd_mips_elf_section_from_bfd_section
6988 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
6989 #define elf_backend_link_output_symbol_hook \
6990                                         _bfd_mips_elf_link_output_symbol_hook
6991 #define elf_backend_create_dynamic_sections \
6992                                         mips_elf64_create_dynamic_sections
6993 #define elf_backend_check_relocs        mips_elf64_check_relocs
6994 #define elf_backend_adjust_dynamic_symbol \
6995                                         mips_elf64_adjust_dynamic_symbol
6996 #define elf_backend_always_size_sections \
6997                                         mips_elf64_always_size_sections
6998 #define elf_backend_size_dynamic_sections \
6999                                         mips_elf64_size_dynamic_sections
7000 #define elf_backend_relocate_section    mips_elf64_relocate_section
7001 #define elf_backend_finish_dynamic_symbol \
7002                                         mips_elf64_finish_dynamic_symbol
7003 #define elf_backend_finish_dynamic_sections \
7004                                         mips_elf64_finish_dynamic_sections
7005 #define elf_backend_final_write_processing \
7006                                         _bfd_mips_elf_final_write_processing
7007 #define elf_backend_additional_program_headers \
7008                                         mips_elf64_additional_program_headers
7009 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
7010 #define elf_backend_gc_mark_hook        mips_elf64_gc_mark_hook
7011 #define elf_backend_gc_sweep_hook       mips_elf64_gc_sweep_hook
7012 #define elf_backend_ecoff_debug_swap    &mips_elf64_ecoff_debug_swap
7013 #define elf_backend_size_info           mips_elf64_size_info
7014
7015 #define elf_backend_got_header_size     (4 * MIPS_RESERVED_GOTNO)
7016 #define elf_backend_plt_header_size     0
7017
7018 /* MIPS ELF64 can use a mixture of REL and RELA, but some Relocations
7019  * work better/work only in RELA, so we default to this.  */
7020 #define elf_backend_may_use_rel_p       1
7021 #define elf_backend_may_use_rela_p      1
7022 #define elf_backend_default_use_rela_p  1
7023
7024 /* We don't set bfd_elf64_bfd_is_local_label_name because the 32-bit
7025    MIPS-specific function only applies to IRIX5, which had no 64-bit
7026    ABI.  */
7027 #define bfd_elf64_find_nearest_line     _bfd_mips_elf_find_nearest_line
7028 #define bfd_elf64_set_section_contents  _bfd_mips_elf_set_section_contents
7029 #define bfd_elf64_bfd_link_hash_table_create \
7030                                         mips_elf64_link_hash_table_create
7031 #define bfd_elf64_bfd_final_link        mips_elf64_final_link
7032 #define bfd_elf64_bfd_merge_private_bfd_data \
7033                                         _bfd_mips_elf_merge_private_bfd_data
7034 #define bfd_elf64_bfd_set_private_flags _bfd_mips_elf_set_private_flags
7035 #define bfd_elf64_bfd_print_private_bfd_data \
7036                                         _bfd_mips_elf_print_private_bfd_data
7037
7038 #define bfd_elf64_get_reloc_upper_bound mips_elf64_get_reloc_upper_bound
7039 #define bfd_elf64_bfd_reloc_type_lookup mips_elf64_reloc_type_lookup
7040 #define bfd_elf64_archive_functions
7041 extern boolean bfd_elf64_archive_slurp_armap
7042   PARAMS((bfd *));
7043 extern boolean bfd_elf64_archive_write_armap
7044   PARAMS((bfd *, unsigned int, struct orl *, unsigned int, int));
7045 #define bfd_elf64_archive_slurp_extended_name_table \
7046                                 _bfd_archive_coff_slurp_extended_name_table
7047 #define bfd_elf64_archive_construct_extended_name_table \
7048                                 _bfd_archive_coff_construct_extended_name_table
7049 #define bfd_elf64_archive_truncate_arname \
7050                                         _bfd_archive_coff_truncate_arname
7051 #define bfd_elf64_archive_read_ar_hdr   _bfd_archive_coff_read_ar_hdr
7052 #define bfd_elf64_archive_openr_next_archived_file \
7053                                 _bfd_archive_coff_openr_next_archived_file
7054 #define bfd_elf64_archive_get_elt_at_index \
7055                                         _bfd_archive_coff_get_elt_at_index
7056 #define bfd_elf64_archive_generic_stat_arch_elt \
7057                                         _bfd_archive_coff_generic_stat_arch_elt
7058 #define bfd_elf64_archive_update_armap_timestamp \
7059                                 _bfd_archive_coff_update_armap_timestamp
7060
7061 /* The SGI style (n)64 NewABI.  */
7062 #define TARGET_LITTLE_SYM               bfd_elf64_littlemips_vec
7063 #define TARGET_LITTLE_NAME              "elf64-littlemips"
7064 #define TARGET_BIG_SYM                  bfd_elf64_bigmips_vec
7065 #define TARGET_BIG_NAME                 "elf64-bigmips"
7066
7067 #include "elf64-target.h"
7068
7069 #define INCLUDED_TARGET_FILE            /* More a type of flag.  */
7070
7071 /* The SYSV-style 'traditional' (n)64 NewABI.  */
7072 #undef TARGET_LITTLE_SYM
7073 #undef TARGET_LITTLE_NAME
7074 #undef TARGET_BIG_SYM
7075 #undef TARGET_BIG_NAME
7076
7077 #define TARGET_LITTLE_SYM               bfd_elf64_tradlittlemips_vec
7078 #define TARGET_LITTLE_NAME              "elf64-tradlittlemips"
7079 #define TARGET_BIG_SYM                  bfd_elf64_tradbigmips_vec
7080 #define TARGET_BIG_NAME                 "elf64-tradbigmips"
7081
7082 /* Include the target file again for this target.  */
7083 #include "elf64-target.h"