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
3400   /* We begin by assuming that the offset for the dynamic relocation
3401      is the same as for the original relocation.  We'll adjust this
3402      later to reflect the correct output offsets.  */
3403   if (elf_section_data (input_section)->sec_info_type != ELF_INFO_TYPE_STABS)
3404     {
3405       outrel[1].r_offset = rel[1].r_offset;
3406       outrel[2].r_offset = rel[2].r_offset;
3407     }
3408   else
3409     {
3410       /* Except that in a stab section things are more complex.
3411          Because we compress stab information, the offset given in the
3412          relocation may not be the one we want; we must let the stabs
3413          machinery tell us the offset.  */
3414       outrel[1].r_offset = outrel[0].r_offset;
3415       outrel[2].r_offset = outrel[0].r_offset;
3416       /* If we didn't need the relocation at all, this value will be
3417          -1.  */
3418       if (outrel[0].r_offset == (bfd_vma) -1)
3419         skip = true;
3420     }
3421
3422   /* If we've decided to skip this relocation, just output an empty
3423      record.  Note that R_MIPS_NONE == 0, so that this call to memset
3424      is a way of setting R_TYPE to R_MIPS_NONE.  */
3425   if (skip)
3426     memset (outrel, 0, sizeof (Elf_Internal_Rel) * 3);
3427   else
3428     {
3429       long indx;
3430       bfd_vma section_offset;
3431
3432       /* We must now calculate the dynamic symbol table index to use
3433          in the relocation.  */
3434       if (h != NULL
3435           && (! info->symbolic || (h->root.elf_link_hash_flags
3436                                    & ELF_LINK_HASH_DEF_REGULAR) == 0))
3437         {
3438           indx = h->root.dynindx;
3439           /* h->root.dynindx may be -1 if this symbol was marked to
3440              become local.  */
3441           if (indx == -1)
3442                 indx = 0;
3443         }
3444       else
3445         {
3446           if (sec != NULL && bfd_is_abs_section (sec))
3447             indx = 0;
3448           else if (sec == NULL || sec->owner == NULL)
3449             {
3450               bfd_set_error (bfd_error_bad_value);
3451               return false;
3452             }
3453           else
3454             {
3455               indx = elf_section_data (sec->output_section)->dynindx;
3456               if (indx == 0)
3457                 abort ();
3458             }
3459
3460           /* Figure out how far the target of the relocation is from
3461              the beginning of its section.  */
3462           section_offset = symbol - sec->output_section->vma;
3463           /* The relocation we're building is section-relative.
3464              Therefore, the original addend must be adjusted by the
3465              section offset.  */
3466           *addendp += section_offset;
3467           /* Now, the relocation is just against the section.  */
3468           symbol = sec->output_section->vma;
3469         }
3470
3471       /* If the relocation was previously an absolute relocation and
3472          this symbol will not be referred to by the relocation, we must
3473          adjust it by the value we give it in the dynamic symbol table.
3474          Otherwise leave the job up to the dynamic linker.  */
3475       if (!indx && r_type != R_MIPS_REL32)
3476         *addendp += symbol;
3477
3478       /* The relocation is always an REL32 relocation because we don't
3479          know where the shared library will wind up at load-time.  */
3480       outrel[0].r_info = ELF64_R_INFO (indx, R_MIPS_REL32);
3481
3482       /* Adjust the output offset of the relocation to reference the
3483          correct location in the output file.  */
3484       outrel[0].r_offset += (input_section->output_section->vma
3485                              + input_section->output_offset);
3486       outrel[1].r_offset += (input_section->output_section->vma
3487                              + input_section->output_offset);
3488       outrel[2].r_offset += (input_section->output_section->vma
3489                              + input_section->output_offset);
3490     }
3491
3492   /* Put the relocation back out.  */
3493   mips_elf64_be_swap_reloc_out (output_bfd, outrel,
3494                                 (sreloc->contents
3495                                  + sreloc->reloc_count
3496                                    * sizeof (Elf64_Mips_External_Rel)));
3497
3498   /* Record the index of the first relocation referencing H.  This
3499      information is later emitted in the .msym section.  */
3500   if (h != NULL
3501       && (h->min_dyn_reloc_index == 0
3502           || sreloc->reloc_count < h->min_dyn_reloc_index))
3503     h->min_dyn_reloc_index = sreloc->reloc_count;
3504
3505   /* We've now added another relocation.  */
3506   ++sreloc->reloc_count;
3507
3508   /* Make sure the output section is writable.  The dynamic linker
3509      will be writing to it.  */
3510   elf_section_data (input_section->output_section)->this_hdr.sh_flags
3511     |= SHF_WRITE;
3512
3513   return true;
3514 }
3515
3516 /* Calculate the value produced by the RELOCATION (which comes from
3517    the INPUT_BFD).  The ADDEND is the addend to use for this
3518    RELOCATION; RELOCATION->R_ADDEND is ignored.
3519
3520    The result of the relocation calculation is stored in VALUEP.
3521    REQUIRE_JALXP indicates whether or not the opcode used with this
3522    relocation must be JALX.
3523
3524    This function returns bfd_reloc_continue if the caller need take no
3525    further action regarding this relocation, bfd_reloc_notsupported if
3526    something goes dramatically wrong, bfd_reloc_overflow if an
3527    overflow occurs, and bfd_reloc_ok to indicate success.  */
3528
3529 static bfd_reloc_status_type
3530 mips_elf64_calculate_relocation (abfd, input_bfd, input_section, info,
3531                                  relocation, addend, howto, local_syms,
3532                                  local_sections, valuep, namep, require_jalxp)
3533      bfd *abfd;
3534      bfd *input_bfd;
3535      asection *input_section;
3536      struct bfd_link_info *info;
3537      const Elf_Internal_Rela *relocation;
3538      bfd_vma addend;
3539      reloc_howto_type *howto;
3540      Elf_Internal_Sym *local_syms;
3541      asection **local_sections;
3542      bfd_vma *valuep;
3543      const char **namep;
3544      boolean *require_jalxp;
3545 {
3546   /* The eventual value we will return.  */
3547   bfd_vma value;
3548   /* The address of the symbol against which the relocation is
3549      occurring.  */
3550   bfd_vma symbol = 0;
3551   /* The final GP value to be used for the relocatable, executable, or
3552      shared object file being produced.  */
3553   bfd_vma gp = (bfd_vma) - 1;
3554   /* The place (section offset or address) of the storage unit being
3555      relocated.  */
3556   bfd_vma p;
3557   /* The value of GP used to create the relocatable object.  */
3558   bfd_vma gp0 = (bfd_vma) - 1;
3559   /* The offset into the global offset table at which the address of
3560      the relocation entry symbol, adjusted by the addend, resides
3561      during execution.  */
3562   bfd_vma g = (bfd_vma) - 1;
3563   /* The section in which the symbol referenced by the relocation is
3564      located.  */
3565   asection *sec = NULL;
3566   struct mips_elf64_link_hash_entry* h = NULL;
3567   /* True if the symbol referred to by this relocation is a local
3568      symbol.  */
3569   boolean local_p;
3570   Elf_Internal_Shdr *symtab_hdr;
3571   size_t extsymoff;
3572   unsigned long r_symndx;
3573   int r_type;
3574   /* True if overflow occurred during the calculation of the
3575      relocation value.  */
3576   boolean overflowed_p;
3577   /* True if this relocation refers to a MIPS16 function.  */
3578   boolean target_is_16_bit_code_p = false;
3579
3580   /* Parse the relocation.  */
3581   r_symndx = ELF64_R_SYM (relocation->r_info);
3582   r_type = ELF64_MIPS_R_TYPE (relocation->r_info);
3583   p = (input_section->output_section->vma
3584        + input_section->output_offset
3585        + relocation->r_offset);
3586
3587   /* Assume that there will be no overflow.  */
3588   overflowed_p = false;
3589
3590   /* Figure out whether or not the symbol is local, and get the offset
3591      used in the array of hash table entries.  */
3592   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3593   local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3594                                          local_sections, false);
3595   if (! elf_bad_symtab (input_bfd))
3596     extsymoff = symtab_hdr->sh_info;
3597   else
3598     {
3599       /* The symbol table does not follow the rule that local symbols
3600          must come before globals.  */
3601       extsymoff = 0;
3602     }
3603
3604   /* Figure out the value of the symbol.  */
3605   if (local_p)
3606     {
3607       Elf_Internal_Sym *sym;
3608
3609       sym = local_syms + r_symndx;
3610       sec = local_sections[r_symndx];
3611
3612       symbol = sec->output_section->vma + sec->output_offset;
3613       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3614         symbol += sym->st_value;
3615
3616       /* MIPS16 text labels should be treated as odd.  */
3617       if (sym->st_other == STO_MIPS16)
3618         ++symbol;
3619
3620       /* Record the name of this symbol, for our caller.  */
3621       *namep = bfd_elf_string_from_elf_section (input_bfd,
3622                                                 symtab_hdr->sh_link,
3623                                                 sym->st_name);
3624       if (*namep == '\0')
3625         *namep = bfd_section_name (input_bfd, sec);
3626
3627       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3628     }
3629   else
3630     {
3631       /* For global symbols we look up the symbol in the hash-table.  */
3632       h = ((struct mips_elf64_link_hash_entry *)
3633            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3634       /* Find the real hash-table entry for this symbol.  */
3635       while (h->root.root.type == bfd_link_hash_indirect
3636              || h->root.root.type == bfd_link_hash_warning)
3637         h = (struct mips_elf64_link_hash_entry *) h->root.root.u.i.link;
3638
3639       /* Record the name of this symbol, for our caller.  */
3640       *namep = h->root.root.root.string;
3641
3642       /* If this symbol is defined, calculate its address.  */
3643       if ((h->root.root.type == bfd_link_hash_defined
3644            || h->root.root.type == bfd_link_hash_defweak)
3645           && h->root.root.u.def.section)
3646         {
3647           sec = h->root.root.u.def.section;
3648           if (sec->output_section)
3649             symbol = (h->root.root.u.def.value
3650                       + sec->output_section->vma
3651                       + sec->output_offset);
3652           else
3653             symbol = h->root.root.u.def.value;
3654         }
3655       else if (h->root.root.type == bfd_link_hash_undefweak)
3656         /* We allow relocations against undefined weak symbols, giving
3657            it the value zero, so that you can undefined weak functions
3658            and check to see if they exist by looking at their
3659            addresses.  */
3660         symbol = 0;
3661       else if (info->shared
3662                && (!info->symbolic || info->allow_shlib_undefined)
3663                && !info->no_undefined
3664                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3665         symbol = 0;
3666       else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
3667               strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
3668         {
3669           /* If this is a dynamic link, we should have created a
3670              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3671              in in mips_elf64_create_dynamic_sections.
3672              Otherwise, we should define the symbol with a value of 0.
3673              FIXME: It should probably get into the symbol table
3674              somehow as well.  */
3675           BFD_ASSERT (! info->shared);
3676           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3677           symbol = 0;
3678         }
3679       else
3680         {
3681           if (! ((*info->callbacks->undefined_symbol)
3682                  (info, h->root.root.root.string, input_bfd,
3683                   input_section, relocation->r_offset,
3684                   (!info->shared || info->no_undefined
3685                    || ELF_ST_VISIBILITY (h->root.other)))))
3686             return bfd_reloc_undefined;
3687           symbol = 0;
3688         }
3689
3690       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3691     }
3692
3693   /* If this is a 64-bit call to a 16-bit function with a stub, we
3694      need to redirect the call to the stub, unless we're already *in*
3695      a stub.  */
3696   if (r_type != R_MIPS16_26 && !info->relocateable
3697       && ((h != NULL && h->fn_stub != NULL)
3698           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3699               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3700       && !mips_elf64_stub_section_p (input_bfd, input_section))
3701     {
3702       /* This is a 64-bit call to a 16-bit function.  We should
3703          have already noticed that we were going to need the
3704          stub.  */
3705       if (local_p)
3706         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3707       else
3708         {
3709           BFD_ASSERT (h->need_fn_stub);
3710           sec = h->fn_stub;
3711         }
3712
3713       symbol = sec->output_section->vma + sec->output_offset;
3714     }
3715   /* If this is a 16-bit call to a 64-bit function with a stub, we
3716      need to redirect the call to the stub.  */
3717   else if (r_type == R_MIPS16_26 && !info->relocateable
3718            && h != NULL
3719            && (h->call_stub != NULL || h->call_fp_stub != NULL)
3720            && !target_is_16_bit_code_p)
3721     {
3722       /* If both call_stub and call_fp_stub are defined, we can figure
3723          out which one to use by seeing which one appears in the input
3724          file.  */
3725       if (h->call_stub != NULL && h->call_fp_stub != NULL)
3726         {
3727           asection *o;
3728
3729           sec = NULL;
3730           for (o = input_bfd->sections; o != NULL; o = o->next)
3731             {
3732               if (strncmp (bfd_get_section_name (input_bfd, o),
3733                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3734                 {
3735                   sec = h->call_fp_stub;
3736                   break;
3737                 }
3738             }
3739           if (sec == NULL)
3740             sec = h->call_stub;
3741         }
3742       else if (h->call_stub != NULL)
3743         sec = h->call_stub;
3744       else
3745         sec = h->call_fp_stub;
3746
3747       BFD_ASSERT (sec->_raw_size > 0);
3748       symbol = sec->output_section->vma + sec->output_offset;
3749     }
3750
3751   /* Calls from 16-bit code to 32-bit code and vice versa require the
3752      special jalx instruction.  */
3753   *require_jalxp = (!info->relocateable
3754                     && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
3755
3756   local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3757                                            local_sections, true);
3758
3759   /* If we haven't already determined the GOT offset, or the GP value,
3760      and we're going to need it, get it now.  */
3761   switch (r_type)
3762     {
3763     case R_MIPS_CALL16:
3764     case R_MIPS_GOT16:
3765     case R_MIPS_GOT_DISP:
3766     case R_MIPS_GOT_HI16:
3767     case R_MIPS_CALL_HI16:
3768     case R_MIPS_GOT_LO16:
3769     case R_MIPS_CALL_LO16:
3770       /* Find the index into the GOT where this value is located.  */
3771       if (!local_p)
3772         {
3773           BFD_ASSERT (addend == 0);
3774           g = mips_elf64_global_got_index (elf_hash_table (info)->dynobj,
3775                                          (struct elf_link_hash_entry*) h);
3776           if (! elf_hash_table(info)->dynamic_sections_created
3777               || (info->shared
3778                   && (info->symbolic || h->root.dynindx == -1)
3779                   && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3780             {
3781               /* This is a static link or a -Bsymbolic link.  The
3782                  symbol is defined locally, or was forced to be local.
3783                  We must initialize this entry in the GOT.  */
3784               bfd *tmpbfd = elf_hash_table (info)->dynobj;
3785
3786               asection *sgot = bfd_get_section_by_name (tmpbfd, ".got");
3787               bfd_put_64 (tmpbfd, symbol + addend, sgot->contents + g);
3788             }
3789         }
3790       else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3791         /* There's no need to create a local GOT entry here; the
3792            calculation for a local GOT16 entry does not involve G.  */
3793         break;
3794       else
3795         {
3796           g = mips_elf64_local_got_index (abfd, info, symbol + addend);
3797           if (g == (bfd_vma) -1)
3798             return false;
3799         }
3800
3801       /* Convert GOT indices to actual offsets.  */
3802       g = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3803                                             abfd, g);
3804       break;
3805
3806     case R_MIPS_HI16:
3807     case R_MIPS_LO16:
3808     case R_MIPS_GPREL16:
3809     case R_MIPS_GPREL32:
3810     case R_MIPS_LITERAL:
3811       gp0 = _bfd_get_gp_value (input_bfd);
3812       gp = _bfd_get_gp_value (abfd);
3813       break;
3814
3815     default:
3816       break;
3817     }
3818
3819   /* Figure out what kind of relocation is being performed.  */
3820   switch (r_type)
3821     {
3822     case R_MIPS_NONE:
3823       return bfd_reloc_continue;
3824
3825     case R_MIPS_16:
3826       value = symbol + mips_elf64_sign_extend (addend, 16);
3827       overflowed_p = mips_elf64_overflow_p (value, 16);
3828       break;
3829
3830     case R_MIPS_32:
3831     case R_MIPS_REL32:
3832     case R_MIPS_64:
3833       if ((info->shared
3834            || (elf_hash_table (info)->dynamic_sections_created
3835                && h != NULL
3836                && ((h->root.elf_link_hash_flags
3837                     & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3838                && ((h->root.elf_link_hash_flags
3839                     & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3840           && r_symndx != 0
3841           && (input_section->flags & SEC_ALLOC) != 0)
3842         {
3843           /* If we're creating a shared library, or this relocation is
3844              against a symbol in a shared library, then we can't know
3845              where the symbol will end up.  So, we create a relocation
3846              record in the output, and leave the job up to the dynamic
3847              linker.  */
3848           value = addend;
3849           if (!mips_elf64_create_dynamic_relocation (abfd, info, relocation,
3850                                                      h, sec, symbol, &value,
3851                                                      input_section))
3852             return false;
3853         }
3854       else
3855         {
3856           if (r_type != R_MIPS_REL32)
3857             value = symbol + addend;
3858           else
3859             value = addend;
3860         }
3861       value &= howto->dst_mask;
3862       break;
3863
3864     case R_MIPS_PC32:
3865     case R_MIPS_PC64:
3866     case R_MIPS_GNU_REL_LO16:
3867       value = symbol + addend - p;
3868       value &= howto->dst_mask;
3869       break;
3870
3871     case R_MIPS_GNU_REL16_S2:
3872       value = symbol + mips_elf64_sign_extend (addend << 2, 18) - p;
3873       overflowed_p = mips_elf64_overflow_p (value, 18);
3874       value = (value >> 2) & howto->dst_mask;
3875       break;
3876
3877     case R_MIPS_GNU_REL_HI16:
3878       value = mips_elf64_high (addend + symbol - p);
3879       value &= howto->dst_mask;
3880       break;
3881
3882     case R_MIPS16_26:
3883       /* The calculation for R_MIPS16_26 is just the same as for an
3884          R_MIPS_26.  It's only the storage of the relocated field into
3885          the output file that's different.  That's handled in
3886          mips_elf_perform_relocation.  So, we just fall through to the
3887          R_MIPS_26 case here.  */
3888     case R_MIPS_26:
3889       if (local_p)
3890         value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3891       else
3892         value = (mips_elf64_sign_extend (addend << 2, 28) + symbol) >> 2;
3893       value &= howto->dst_mask;
3894       break;
3895
3896     case R_MIPS_HI16:
3897       value = mips_elf64_high (addend + symbol);
3898       value &= howto->dst_mask;
3899       break;
3900
3901     case R_MIPS_LO16:
3902         value = (addend + symbol) & 0xffff;
3903         value &= howto->dst_mask;
3904       break;
3905
3906     case R_MIPS_LITERAL:
3907       /* Because we don't merge literal sections, we can handle this
3908          just like R_MIPS_GPREL16.  In the long run, we should merge
3909          shared literals, and then we will need to additional work
3910          here.  */
3911
3912       /* Fall through.  */
3913
3914     case R_MIPS_GPREL16:
3915       if (local_p)
3916         value = mips_elf64_sign_extend (addend, 16) + symbol + gp0 - gp;
3917       else
3918         value = mips_elf64_sign_extend (addend, 16) + symbol - gp;
3919       overflowed_p = mips_elf64_overflow_p (value, 16);
3920       break;
3921
3922     case R_MIPS_PC16:
3923       value = mips_elf64_sign_extend (addend, 16) + symbol - p;
3924       overflowed_p = mips_elf64_overflow_p (value, 16);
3925       value = (bfd_vma) ((bfd_signed_vma) value / 4);
3926       break;
3927
3928     case R_MIPS_GOT16:
3929     case R_MIPS_CALL16:
3930       if (local_p)
3931         {
3932           boolean forced;
3933
3934           /* The special case is when the symbol is forced to be local.  We
3935              need the full address in the GOT since no R_MIPS_LO16 relocation
3936              follows.  */
3937           forced = ! mips_elf64_local_relocation_p (input_bfd, relocation,
3938                                                   local_sections, false);
3939           value = mips_elf64_got16_entry (abfd, info, symbol + addend, forced);
3940           if (value == (bfd_vma) -1)
3941             return false;
3942           value
3943             = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3944                                               abfd,
3945                                               value);
3946           overflowed_p = mips_elf64_overflow_p (value, 16);
3947           break;
3948         }
3949
3950       /* Fall through.  */
3951
3952     case R_MIPS_GOT_DISP:
3953       value = g;
3954       overflowed_p = mips_elf64_overflow_p (value, 16);
3955       break;
3956
3957     case R_MIPS_GPREL32:
3958       value = (addend + symbol + gp0 - gp) & howto->dst_mask;
3959       break;
3960
3961     case R_MIPS_GOT_HI16:
3962     case R_MIPS_CALL_HI16:
3963       /* We're allowed to handle these two relocations identically.
3964          The dynamic linker is allowed to handle the CALL relocations
3965          differently by creating a lazy evaluation stub.  */
3966       value = g;
3967       value = mips_elf64_high (value);
3968       value &= howto->dst_mask;
3969       break;
3970
3971     case R_MIPS_GOT_LO16:
3972     case R_MIPS_CALL_LO16:
3973       value = g & howto->dst_mask;
3974       break;
3975
3976     case R_MIPS_GOT_PAGE:
3977       value = mips_elf64_got_page (abfd, info, symbol + addend, NULL);
3978       if (value == (bfd_vma) -1)
3979         return false;
3980       value = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3981                                               abfd,
3982                                               value);
3983       overflowed_p = mips_elf64_overflow_p (value, 16);
3984       break;
3985
3986     case R_MIPS_GOT_OFST:
3987       mips_elf64_got_page (abfd, info, symbol + addend, &value);
3988       overflowed_p = mips_elf64_overflow_p (value, 16);
3989       break;
3990
3991     case R_MIPS_SUB:
3992       value = symbol - addend;
3993       value &= howto->dst_mask;
3994       break;
3995
3996     case R_MIPS_HIGHER:
3997       value = mips_elf64_higher (addend + symbol);
3998       value &= howto->dst_mask;
3999       break;
4000
4001     case R_MIPS_HIGHEST:
4002       value = mips_elf64_highest (addend + symbol);
4003       value &= howto->dst_mask;
4004       break;
4005
4006     case R_MIPS_SCN_DISP:
4007       value = symbol + addend - sec->output_offset;
4008       value &= howto->dst_mask;
4009       break;
4010
4011     case R_MIPS_PJUMP:
4012     case R_MIPS_JALR:
4013       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
4014          hint; we could improve performance by honoring that hint.  */
4015       return bfd_reloc_continue;
4016
4017     case R_MIPS_GNU_VTINHERIT:
4018     case R_MIPS_GNU_VTENTRY:
4019       /* We don't do anything with these at present.  */
4020       return bfd_reloc_continue;
4021
4022     default:
4023       /* An unrecognized relocation type.  */
4024       return bfd_reloc_notsupported;
4025     }
4026
4027   /* Store the VALUE for our caller.  */
4028   *valuep = value;
4029   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
4030 }
4031 \f
4032 /* Obtain the field relocated by RELOCATION.  */
4033
4034 static bfd_vma
4035 mips_elf64_obtain_contents (howto, relocation, input_bfd, contents)
4036      reloc_howto_type *howto;
4037      const Elf_Internal_Rela *relocation;
4038      bfd *input_bfd;
4039      bfd_byte *contents;
4040 {
4041   bfd_byte *location = contents + relocation->r_offset;
4042
4043   /* Obtain the bytes.  */
4044   return bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
4045 }
4046
4047 /* It has been determined that the result of the RELOCATION is the
4048    VALUE.  Use HOWTO to place VALUE into the output file at the
4049    appropriate position.  The SECTION is the section to which the
4050    relocation applies.  If REQUIRE_JALX is true, then the opcode used
4051    for the relocation must be either JAL or JALX, and it is
4052    unconditionally converted to JALX.
4053
4054    Returns false if anything goes wrong.  */
4055
4056 static boolean
4057 mips_elf64_perform_relocation (info, howto, relocation, value,
4058                              input_bfd, input_section,
4059                              contents, require_jalx)
4060      struct bfd_link_info *info;
4061      reloc_howto_type *howto;
4062      const Elf_Internal_Rela *relocation;
4063      bfd_vma value;
4064      bfd *input_bfd;
4065      asection *input_section;
4066      bfd_byte *contents;
4067      boolean require_jalx;
4068 {
4069   bfd_vma x;
4070   bfd_byte *location;
4071   int r_type = ELF32_R_TYPE (relocation->r_info);
4072
4073   /* Figure out where the relocation is occurring.  */
4074   location = contents + relocation->r_offset;
4075
4076   /* Obtain the current value.  */
4077   x = mips_elf64_obtain_contents (howto, relocation, input_bfd, contents);
4078
4079   /* Clear the field we are setting.  */
4080   x &= ~howto->dst_mask;
4081
4082   /* If this is the R_MIPS16_26 relocation, we must store the
4083      value in a funny way.  */
4084   if (r_type == R_MIPS16_26)
4085     {
4086       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
4087          Most mips16 instructions are 16 bits, but these instructions
4088          are 32 bits.
4089
4090          The format of these instructions is:
4091
4092          +--------------+--------------------------------+
4093          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
4094          +--------------+--------------------------------+
4095          !                Immediate  15:0                   !
4096          +-----------------------------------------------+
4097
4098          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
4099          Note that the immediate value in the first word is swapped.
4100
4101          When producing a relocateable object file, R_MIPS16_26 is
4102          handled mostly like R_MIPS_26.  In particular, the addend is
4103          stored as a straight 26-bit value in a 32-bit instruction.
4104          (gas makes life simpler for itself by never adjusting a
4105          R_MIPS16_26 reloc to be against a section, so the addend is
4106          always zero).  However, the 32 bit instruction is stored as 2
4107          16-bit values, rather than a single 32-bit value.  In a
4108          big-endian file, the result is the same; in a little-endian
4109          file, the two 16-bit halves of the 32 bit value are swapped.
4110          This is so that a disassembler can recognize the jal
4111          instruction.
4112
4113          When doing a final link, R_MIPS16_26 is treated as a 32 bit
4114          instruction stored as two 16-bit values.  The addend A is the
4115          contents of the targ26 field.  The calculation is the same as
4116          R_MIPS_26.  When storing the calculated value, reorder the
4117          immediate value as shown above, and don't forget to store the
4118          value as two 16-bit values.
4119
4120          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
4121          defined as
4122
4123          big-endian:
4124          +--------+----------------------+
4125          |        |                      |
4126          |        |    targ26-16         |
4127          |31    26|25                   0|
4128          +--------+----------------------+
4129
4130          little-endian:
4131          +----------+------+-------------+
4132          |          |      |             |
4133          |  sub1    |      |     sub2    |
4134          |0        9|10  15|16         31|
4135          +----------+--------------------+
4136          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
4137          ((sub1 << 16) | sub2)).
4138
4139          When producing a relocateable object file, the calculation is
4140          (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4141          When producing a fully linked file, the calculation is
4142          let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4143          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
4144
4145       if (!info->relocateable)
4146         /* Shuffle the bits according to the formula above.  */
4147         value = (((value & 0x1f0000) << 5)
4148                  | ((value & 0x3e00000) >> 5)
4149                  | (value & 0xffff));
4150     }
4151   else if (r_type == R_MIPS16_GPREL)
4152     {
4153       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
4154          mode.  A typical instruction will have a format like this:
4155
4156          +--------------+--------------------------------+
4157          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
4158          +--------------+--------------------------------+
4159          !    Major     !   rx   !   ry   !   Imm  4:0   !
4160          +--------------+--------------------------------+
4161
4162          EXTEND is the five bit value 11110.  Major is the instruction
4163          opcode.
4164
4165          This is handled exactly like R_MIPS_GPREL16, except that the
4166          addend is retrieved and stored as shown in this diagram; that
4167          is, the Imm fields above replace the V-rel16 field.
4168
4169          All we need to do here is shuffle the bits appropriately.  As
4170          above, the two 16-bit halves must be swapped on a
4171          little-endian system.  */
4172       value = (((value & 0x7e0) << 16)
4173                | ((value & 0xf800) << 5)
4174                | (value & 0x1f));
4175     }
4176
4177   /* Set the field.  */
4178   x |= (value & howto->dst_mask);
4179
4180   /* If required, turn JAL into JALX.  */
4181   if (require_jalx)
4182     {
4183       boolean ok;
4184       bfd_vma opcode = x >> 26;
4185       bfd_vma jalx_opcode;
4186
4187       /* Check to see if the opcode is already JAL or JALX.  */
4188       if (r_type == R_MIPS16_26)
4189         {
4190           ok = ((opcode == 0x6) || (opcode == 0x7));
4191           jalx_opcode = 0x7;
4192         }
4193       else
4194         {
4195           ok = ((opcode == 0x3) || (opcode == 0x1d));
4196           jalx_opcode = 0x1d;
4197         }
4198
4199       /* If the opcode is not JAL or JALX, there's a problem.  */
4200       if (!ok)
4201         {
4202           (*_bfd_error_handler)
4203             (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
4204              bfd_archive_filename (input_bfd),
4205              input_section->name,
4206              (unsigned long) relocation->r_offset);
4207           bfd_set_error (bfd_error_bad_value);
4208           return false;
4209         }
4210
4211       /* Make this the JALX opcode.  */
4212       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
4213     }
4214
4215   /* Swap the high- and low-order 16 bits on little-endian systems
4216      when doing a MIPS16 relocation.  */
4217   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
4218       && bfd_little_endian (input_bfd))
4219     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
4220
4221   /* Put the value into the output.  */
4222   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
4223   return true;
4224 }
4225
4226 /* Returns true if SECTION is a MIPS16 stub section.  */
4227
4228 static boolean
4229 mips_elf64_stub_section_p (abfd, section)
4230      bfd *abfd ATTRIBUTE_UNUSED;
4231      asection *section;
4232 {
4233   const char *name = bfd_get_section_name (abfd, section);
4234
4235   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
4236           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
4237           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
4238 }
4239
4240 /* Relocate a MIPS ELF64 section.  */
4241
4242 static boolean
4243 mips_elf64_relocate_section (output_bfd, info, input_bfd, input_section,
4244                              contents, relocs, local_syms, local_sections)
4245      bfd *output_bfd;
4246      struct bfd_link_info *info;
4247      bfd *input_bfd;
4248      asection *input_section;
4249      bfd_byte *contents;
4250      Elf_Internal_Rela *relocs;
4251      Elf_Internal_Sym *local_syms;
4252      asection **local_sections;
4253 {
4254   Elf_Internal_Rela *rel;
4255   const Elf_Internal_Rela *relend;
4256   bfd_vma addend = 0;
4257   boolean use_saved_addend_p = false;
4258   struct elf_backend_data *bed;
4259
4260   bed = get_elf_backend_data (output_bfd);
4261   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
4262   for (rel = relocs; rel < relend; ++rel)
4263     {
4264       const char *name;
4265       bfd_vma value;
4266       reloc_howto_type *howto;
4267       boolean require_jalx;
4268       /* True if the relocation is a RELA relocation, rather than a
4269          REL relocation.  */
4270       boolean rela_relocation_p = true;
4271       int r_type = ELF64_MIPS_R_TYPE (rel->r_info);
4272       const char *msg = (const char *) NULL;
4273
4274       /* Find the relocation howto for this relocation.  */
4275       howto = &mips_elf64_howto_table_rela[r_type];
4276
4277       if (!use_saved_addend_p)
4278         {
4279           Elf_Internal_Shdr *rel_hdr;
4280
4281           /* If these relocations were originally of the REL variety,
4282              we must pull the addend out of the field that will be
4283              relocated.  Otherwise, we simply use the contents of the
4284              RELA relocation.  To determine which flavor or relocation
4285              this is, we depend on the fact that the INPUT_SECTION's
4286              REL_HDR is read before its REL_HDR2.  */
4287           rel_hdr = &elf_section_data (input_section)->rel_hdr;
4288           if ((size_t) (rel - relocs)
4289               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
4290             rel_hdr = elf_section_data (input_section)->rel_hdr2;
4291           if (rel_hdr->sh_entsize
4292               == (get_elf_backend_data (input_bfd)->s->sizeof_rel))
4293             {
4294               /* Note that this is a REL relocation.  */
4295               rela_relocation_p = false;
4296
4297               /* Find the relocation howto for this relocation.  */
4298               howto = &mips_elf64_howto_table_rel[r_type];
4299
4300               /* Get the addend, which is stored in the input file.  */
4301               addend = mips_elf64_obtain_contents (howto,
4302                                                    rel,
4303                                                    input_bfd,
4304                                                    contents);
4305               addend &= howto->src_mask;
4306
4307               /* For some kinds of relocations, the ADDEND is a
4308                  combination of the addend stored in two different
4309                  relocations.   */
4310               if (r_type == R_MIPS_HI16
4311                   || r_type == R_MIPS_GNU_REL_HI16
4312                   || (r_type == R_MIPS_GOT16
4313                       && mips_elf64_local_relocation_p (input_bfd, rel,
4314                                                       local_sections, false)))
4315                 {
4316                   bfd_vma l;
4317                   const Elf_Internal_Rela *lo16_relocation;
4318                   reloc_howto_type *lo16_howto;
4319                   int lo;
4320
4321                   /* The combined value is the sum of the HI16 addend,
4322                      left-shifted by sixteen bits, and the LO16
4323                      addend, sign extended.  (Usually, the code does
4324                      a `lui' of the HI16 value, and then an `addiu' of
4325                      the LO16 value.)
4326
4327                      Scan ahead to find a matching LO16 relocation.  */
4328                   if (r_type == R_MIPS_GNU_REL_HI16)
4329                     lo = R_MIPS_GNU_REL_LO16;
4330                   else
4331                     lo = R_MIPS_LO16;
4332                   lo16_relocation
4333                     = mips_elf64_next_relocation (lo, rel, relend);
4334                   if (lo16_relocation == NULL)
4335                     return false;
4336
4337                   /* Obtain the addend kept there.  */
4338                   if (rela_relocation_p == false)
4339                     lo16_howto = &mips_elf64_howto_table_rel[lo];
4340                   else
4341                     lo16_howto = &mips_elf64_howto_table_rela[lo];
4342                   l = mips_elf64_obtain_contents (lo16_howto,
4343                                                 lo16_relocation,
4344                                                 input_bfd, contents);
4345                   l &= lo16_howto->src_mask;
4346                   l = mips_elf64_sign_extend (l, 16);
4347
4348                   addend <<= 16;
4349
4350                   /* Compute the combined addend.  */
4351                   addend += l;
4352                 }
4353             }
4354           else
4355             addend = rel->r_addend;
4356         }
4357
4358       if (info->relocateable)
4359         {
4360           Elf_Internal_Sym *sym;
4361           unsigned long r_symndx;
4362
4363           /* Since we're just relocating, all we need to do is copy
4364              the relocations back out to the object file, unless
4365              they're against a section symbol, in which case we need
4366              to adjust by the section offset, or unless they're GP
4367              relative in which case we need to adjust by the amount
4368              that we're adjusting GP in this relocateable object.  */
4369
4370           if (!mips_elf64_local_relocation_p (input_bfd, rel, local_sections,
4371                                             false))
4372             /* There's nothing to do for non-local relocations.  */
4373             continue;
4374
4375           if (r_type == R_MIPS_GPREL16
4376               || r_type == R_MIPS_GPREL32
4377               || r_type == R_MIPS_LITERAL)
4378             addend -= (_bfd_get_gp_value (output_bfd)
4379                        - _bfd_get_gp_value (input_bfd));
4380           else if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4381             /* The addend is stored without its two least
4382                significant bits (which are always zero.)  In a
4383                non-relocateable link, calculate_relocation will do
4384                this shift; here, we must do it ourselves.  */
4385             addend <<= 2;
4386
4387           r_symndx = ELF64_R_SYM (rel->r_info);
4388           sym = local_syms + r_symndx;
4389           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4390             /* Adjust the addend appropriately.  */
4391             addend += local_sections[r_symndx]->output_offset;
4392
4393 #if 0
4394           /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
4395              then we only want to write out the high-order 16 bits.
4396              The subsequent R_MIPS_LO16 will handle the low-order bits.  */
4397           if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
4398               || r_type == R_MIPS_GNU_REL_HI16)
4399             addend = mips_elf64_high (addend);
4400           else if (r_type == R_MIPS_HIGHER)
4401             addend = mips_elf64_higher (addend);
4402           else if (r_type == R_MIPS_HIGHEST)
4403             addend = mips_elf64_highest (addend);
4404 #endif
4405           /* If the relocation is for an R_MIPS_26 relocation, then
4406              the two low-order bits are not stored in the object file;
4407              they are implicitly zero.  */
4408           if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4409             addend >>= 2;
4410
4411           if (rela_relocation_p)
4412             /* If this is a RELA relocation, just update the addend.
4413                We have to cast away constness for REL.  */
4414             rel->r_addend = addend;
4415           else
4416             {
4417               /* Otherwise, we have to write the value back out.  Note
4418                  that we use the source mask, rather than the
4419                  destination mask because the place to which we are
4420                  writing will be source of the addend in the final
4421                  link.  */
4422               addend &= howto->src_mask;
4423
4424               if (!mips_elf64_perform_relocation (info, howto, rel, addend,
4425                                                   input_bfd, input_section,
4426                                                   contents, false))
4427                 return false;
4428             }
4429
4430           /* Go on to the next relocation.  */
4431           continue;
4432         }
4433
4434       /* In the N32 and 64-bit ABIs there may be multiple consecutive
4435          relocations for the same offset.  In that case we are
4436          supposed to treat the output of each relocation as the addend
4437          for the next.  */
4438       if (rel + 1 < relend
4439           && rel->r_offset == rel[1].r_offset
4440           && ELF64_MIPS_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
4441         use_saved_addend_p = true;
4442       else
4443         use_saved_addend_p = false;
4444
4445       /* Figure out what value we are supposed to relocate.  */
4446       switch (mips_elf64_calculate_relocation (output_bfd, input_bfd,
4447                                                input_section, info, rel,
4448                                                addend, howto, local_syms,
4449                                                local_sections, &value, &name,
4450                                                &require_jalx))
4451         {
4452         case bfd_reloc_continue:
4453           /* There's nothing to do.  */
4454           continue;
4455
4456         case bfd_reloc_undefined:
4457           /* mips_elf64_calculate_relocation already called the
4458              undefined_symbol callback.  There's no real point in
4459              trying to perform the relocation at this point, so we
4460              just skip ahead to the next relocation.  */
4461           continue;
4462
4463         case bfd_reloc_notsupported:
4464           msg = _("internal error: unsupported relocation error");
4465           info->callbacks->warning
4466             (info, msg, name, input_bfd, input_section, rel->r_offset);
4467           return false;
4468
4469         case bfd_reloc_overflow:
4470           if (use_saved_addend_p)
4471             /* Ignore overflow until we reach the last relocation for
4472                a given location.  */
4473             ;
4474           else
4475             {
4476               BFD_ASSERT (name != NULL);
4477               if (! ((*info->callbacks->reloc_overflow)
4478                      (info, name, howto->name, (bfd_vma) 0,
4479                       input_bfd, input_section, rel->r_offset)))
4480                 return false;
4481             }
4482           break;
4483
4484         case bfd_reloc_ok:
4485           break;
4486
4487         default:
4488           abort ();
4489           break;
4490         }
4491
4492       /* If we've got another relocation for the address, keep going
4493          until we reach the last one.  */
4494       if (use_saved_addend_p)
4495         {
4496           addend = value;
4497           continue;
4498         }
4499
4500       /* Actually perform the relocation.  */
4501       if (!mips_elf64_perform_relocation (info, howto, rel, value, input_bfd,
4502                                           input_section, contents,
4503                                           require_jalx))
4504         return false;
4505     }
4506
4507   return true;
4508 }
4509
4510 /* Create dynamic sections when linking against a dynamic object.  */
4511
4512 boolean
4513 mips_elf64_create_dynamic_sections (abfd, info)
4514      bfd *abfd;
4515      struct bfd_link_info *info;
4516 {
4517   flagword flags;
4518   register asection *s;
4519
4520   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4521            | SEC_LINKER_CREATED | SEC_READONLY);
4522
4523   /* Mips ABI requests the .dynamic section to be read only.  */
4524   s = bfd_get_section_by_name (abfd, ".dynamic");
4525   if (s != NULL)
4526     {
4527       if (! bfd_set_section_flags (abfd, s, flags))
4528         return false;
4529     }
4530
4531   /* We need to create .got section.  */
4532   if (! mips_elf64_create_got_section (abfd, info))
4533     return false;
4534
4535   /* Create the .msym section on IRIX6.  It is used by the dynamic
4536      linker to speed up dynamic relocations, and to avoid computing
4537      the ELF hash for symbols.  */
4538   if (!mips_elf64_create_msym_section (abfd))
4539     return false;
4540
4541   /* Create .stub section.  */
4542   if (bfd_get_section_by_name (abfd, ".MIPS.stubs") == NULL)
4543     {
4544       s = bfd_make_section (abfd, ".MIPS.stubs");
4545       if (s == NULL
4546           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4547           || ! bfd_set_section_alignment (abfd, s, 3))
4548         return false;
4549     }
4550
4551   return true;
4552 }
4553
4554 /* Adjust a symbol defined by a dynamic object and referenced by a
4555    regular object.  The current definition is in some section of the
4556    dynamic object, but we're not including those sections.  We have to
4557    change the definition to something the rest of the link can
4558    understand.  */
4559
4560 boolean
4561 mips_elf64_adjust_dynamic_symbol (info, h)
4562      struct bfd_link_info *info;
4563      struct elf_link_hash_entry *h;
4564 {
4565   bfd *dynobj;
4566   struct mips_elf64_link_hash_entry *hmips;
4567   asection *s;
4568
4569   dynobj = elf_hash_table (info)->dynobj;
4570
4571   /* Make sure we know what is going on here.  */
4572   BFD_ASSERT (dynobj != NULL
4573               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
4574                   || h->weakdef != NULL
4575                   || ((h->elf_link_hash_flags
4576                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4577                       && (h->elf_link_hash_flags
4578                           & ELF_LINK_HASH_REF_REGULAR) != 0
4579                       && (h->elf_link_hash_flags
4580                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
4581
4582   /* If this symbol is defined in a dynamic object, we need to copy
4583      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
4584      file.  */
4585   hmips = (struct mips_elf64_link_hash_entry *) h;
4586   if (! info->relocateable
4587       && hmips->possibly_dynamic_relocs != 0
4588       && (h->root.type == bfd_link_hash_defweak
4589           || (h->elf_link_hash_flags
4590               & ELF_LINK_HASH_DEF_REGULAR) == 0))
4591     {
4592       mips_elf64_allocate_dynamic_relocations (dynobj,
4593                                                hmips->possibly_dynamic_relocs);
4594       if (hmips->readonly_reloc)
4595         /* We tell the dynamic linker that there are relocations
4596            against the text segment.  */
4597         info->flags |= DF_TEXTREL;
4598     }
4599
4600   /* For a function, create a stub, if allowed.  */
4601   if (! hmips->no_fn_stub
4602       && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4603     {
4604       if (! elf_hash_table (info)->dynamic_sections_created)
4605         return true;
4606
4607       /* If this symbol is not defined in a regular file, then set
4608          the symbol to the stub location.  This is required to make
4609          function pointers compare as equal between the normal
4610          executable and the shared library.  */
4611       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4612         {
4613           /* We need .stub section.  */
4614           s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
4615           BFD_ASSERT (s != NULL);
4616
4617           h->root.u.def.section = s;
4618           h->root.u.def.value = s->_raw_size;
4619
4620           /* XXX Write this stub address somewhere.  */
4621           h->plt.offset = s->_raw_size;
4622
4623           /* Make room for this stub code.  */
4624           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4625
4626           /* The last half word of the stub will be filled with the index
4627              of this symbol in .dynsym section.  */
4628           return true;
4629         }
4630     }
4631   else if ((h->type == STT_FUNC)
4632            && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
4633     {
4634       /* This will set the entry for this symbol in the GOT to 0, and
4635          the dynamic linker will take care of this.  */
4636       h->root.u.def.value = 0;
4637       return true;
4638     }
4639
4640   /* If this is a weak symbol, and there is a real definition, the
4641      processor independent code will have arranged for us to see the
4642      real definition first, and we can just use the same value.  */
4643   if (h->weakdef != NULL)
4644     {
4645       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
4646                   || h->weakdef->root.type == bfd_link_hash_defweak);
4647       h->root.u.def.section = h->weakdef->root.u.def.section;
4648       h->root.u.def.value = h->weakdef->root.u.def.value;
4649       return true;
4650     }
4651
4652   /* This is a reference to a symbol defined by a dynamic object which
4653      is not a function.  */
4654
4655   return true;
4656 }
4657
4658 /* This function is called after all the input files have been read,
4659    and the input sections have been assigned to output sections.  */
4660
4661 boolean
4662 mips_elf64_always_size_sections (output_bfd, info)
4663      bfd *output_bfd ATTRIBUTE_UNUSED;
4664      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4665 {
4666   if (info->relocateable
4667       || ! mips_elf64_hash_table (info)->mips16_stubs_seen)
4668     return true;
4669
4670   mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
4671                                  mips_elf64_check_mips16_stubs,
4672                                  (PTR) NULL);
4673
4674   return true;
4675 }
4676
4677 /* Check the mips16 stubs for a particular symbol, and see if we can
4678    discard them.  */
4679
4680 static boolean
4681 mips_elf64_check_mips16_stubs (h, data)
4682      struct mips_elf64_link_hash_entry *h;
4683      PTR data ATTRIBUTE_UNUSED;
4684 {
4685   if (h->fn_stub != NULL
4686       && ! h->need_fn_stub)
4687     {
4688       /* We don't need the fn_stub; the only references to this symbol
4689          are 16 bit calls.  Clobber the size to 0 to prevent it from
4690          being included in the link.  */
4691       h->fn_stub->_raw_size = 0;
4692       h->fn_stub->_cooked_size = 0;
4693       h->fn_stub->flags &= ~SEC_RELOC;
4694       h->fn_stub->reloc_count = 0;
4695       h->fn_stub->flags |= SEC_EXCLUDE;
4696     }
4697
4698   if (h->call_stub != NULL
4699       && h->root.other == STO_MIPS16)
4700     {
4701       /* We don't need the call_stub; this is a 16 bit function, so
4702          calls from other 16 bit functions are OK.  Clobber the size
4703          to 0 to prevent it from being included in the link.  */
4704       h->call_stub->_raw_size = 0;
4705       h->call_stub->_cooked_size = 0;
4706       h->call_stub->flags &= ~SEC_RELOC;
4707       h->call_stub->reloc_count = 0;
4708       h->call_stub->flags |= SEC_EXCLUDE;
4709     }
4710
4711   if (h->call_fp_stub != NULL
4712       && h->root.other == STO_MIPS16)
4713     {
4714       /* We don't need the call_stub; this is a 16 bit function, so
4715          calls from other 16 bit functions are OK.  Clobber the size
4716          to 0 to prevent it from being included in the link.  */
4717       h->call_fp_stub->_raw_size = 0;
4718       h->call_fp_stub->_cooked_size = 0;
4719       h->call_fp_stub->flags &= ~SEC_RELOC;
4720       h->call_fp_stub->reloc_count = 0;
4721       h->call_fp_stub->flags |= SEC_EXCLUDE;
4722     }
4723
4724   return true;
4725 }
4726
4727 /* Set the sizes of the dynamic sections.  */
4728
4729 boolean
4730 mips_elf64_size_dynamic_sections (output_bfd, info)
4731      bfd *output_bfd;
4732      struct bfd_link_info *info;
4733 {
4734   bfd *dynobj;
4735   asection *s;
4736   boolean reltext;
4737   struct mips_elf64_got_info *g = NULL;
4738
4739   dynobj = elf_hash_table (info)->dynobj;
4740   BFD_ASSERT (dynobj != NULL);
4741
4742   if (elf_hash_table (info)->dynamic_sections_created)
4743     {
4744       /* Set the contents of the .interp section to the interpreter.  */
4745       if (! info->shared)
4746         {
4747           s = bfd_get_section_by_name (dynobj, ".interp");
4748           BFD_ASSERT (s != NULL);
4749           s->_raw_size = strlen ("/usr/lib64/libc.so.1") + 1;
4750           s->contents = (bfd_byte *) "/usr/lib64/libc.so.1";
4751         }
4752     }
4753
4754   /* The check_relocs and adjust_dynamic_symbol entry points have
4755      determined the sizes of the various dynamic sections.  Allocate
4756      memory for them.  */
4757   reltext = false;
4758   for (s = dynobj->sections; s != NULL; s = s->next)
4759     {
4760       const char *name;
4761       boolean strip;
4762
4763       /* It's OK to base decisions on the section name, because none
4764          of the dynobj section names depend upon the input files.  */
4765       name = bfd_get_section_name (dynobj, s);
4766
4767       if ((s->flags & SEC_LINKER_CREATED) == 0)
4768         continue;
4769
4770       strip = false;
4771
4772       if (strncmp (name, ".rel", 4) == 0)
4773         {
4774           if (s->_raw_size == 0)
4775             {
4776               /* We only strip the section if the output section name
4777                  has the same name.  Otherwise, there might be several
4778                  input sections for this output section.  FIXME: This
4779                  code is probably not needed these days anyhow, since
4780                  the linker now does not create empty output sections.  */
4781               if (s->output_section != NULL
4782                   && strcmp (name,
4783                              bfd_get_section_name (s->output_section->owner,
4784                                                    s->output_section)) == 0)
4785                 strip = true;
4786             }
4787           else
4788             {
4789               const char *outname;
4790               asection *target;
4791
4792               /* If this relocation section applies to a read only
4793                  section, then we probably need a DT_TEXTREL entry.
4794                  If the relocation section is .rel.dyn, we always
4795                  assert a DT_TEXTREL entry rather than testing whether
4796                  there exists a relocation to a read only section or
4797                  not.  */
4798               outname = bfd_get_section_name (output_bfd,
4799                                               s->output_section);
4800               target = bfd_get_section_by_name (output_bfd, outname + 4);
4801               if ((target != NULL
4802                    && (target->flags & SEC_READONLY) != 0
4803                    && (target->flags & SEC_ALLOC) != 0)
4804                   || strcmp (outname, "rel.dyn") == 0)
4805                 reltext = true;
4806
4807               /* We use the reloc_count field as a counter if we need
4808                  to copy relocs into the output file.  */
4809               if (strcmp (name, "rel.dyn") != 0)
4810                 s->reloc_count = 0;
4811             }
4812         }
4813       else if (strncmp (name, ".got", 4) == 0)
4814         {
4815           int i;
4816           bfd_size_type loadable_size = 0;
4817           bfd_size_type local_gotno;
4818           bfd *sub;
4819
4820           BFD_ASSERT (elf_section_data (s) != NULL);
4821           g = (struct mips_elf64_got_info *) elf_section_data (s)->tdata;
4822           BFD_ASSERT (g != NULL);
4823
4824           /* Calculate the total loadable size of the output.  That
4825              will give us the maximum number of GOT_PAGE entries
4826              required.  */
4827           for (sub = info->input_bfds; sub; sub = sub->link_next)
4828             {
4829               asection *subsection;
4830
4831               for (subsection = sub->sections;
4832                    subsection;
4833                    subsection = subsection->next)
4834                 {
4835                   if ((subsection->flags & SEC_ALLOC) == 0)
4836                     continue;
4837                   loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
4838                 }
4839             }
4840           loadable_size += MIPS_FUNCTION_STUB_SIZE;
4841
4842           /* Assume there are two loadable segments consisting of
4843              contiguous sections.  Is 5 enough?  */
4844           local_gotno = (loadable_size >> 16) + 5;
4845             /* It's possible we will need GOT_PAGE entries as well as
4846                GOT16 entries.  Often, these will be able to share GOT
4847                entries, but not always.  */
4848             local_gotno *= 2;
4849
4850           g->local_gotno += local_gotno;
4851           s->_raw_size += local_gotno * 8;
4852
4853           /* There has to be a global GOT entry for every symbol with
4854              a dynamic symbol table index of DT_MIPS_GOTSYM or
4855              higher.  Therefore, it make sense to put those symbols
4856              that need GOT entries at the end of the symbol table.  We
4857              do that here.  */
4858           if (!mips_elf64_sort_hash_table (info, 1))
4859             return false;
4860
4861           if (g->global_gotsym != NULL)
4862             i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
4863           else
4864             /* If there are no global symbols, or none requiring
4865                relocations, then GLOBAL_GOTSYM will be NULL.  */
4866             i = 0;
4867           g->global_gotno = i;
4868           s->_raw_size += i * 8;
4869         }
4870       else if (strcmp (name, ".MIPS.stubs") == 0)
4871         {
4872           /* Irix rld assumes that the function stub isn't at the end
4873              of .text section. So put a dummy. XXX  */
4874           s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4875         }
4876       else if (strcmp (name, ".msym")
4877                == 0)
4878         s->_raw_size = (sizeof (Elf32_External_Msym)
4879                         * (elf_hash_table (info)->dynsymcount
4880                            + bfd_count_sections (output_bfd)));
4881       else if (strncmp (name, ".init", 5) != 0)
4882         {
4883           /* It's not one of our sections, so don't allocate space.  */
4884           continue;
4885         }
4886
4887       if (strip)
4888         {
4889           _bfd_strip_section_from_output (info, s);
4890           continue;
4891         }
4892
4893       /* Allocate memory for the section contents.  */
4894       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4895       if (s->contents == NULL && s->_raw_size != 0)
4896         {
4897           bfd_set_error (bfd_error_no_memory);
4898           return false;
4899         }
4900     }
4901
4902   if (elf_hash_table (info)->dynamic_sections_created)
4903     {
4904       /* Add some entries to the .dynamic section.  We fill in the
4905          values later, in elf_mips_finish_dynamic_sections, but we
4906          must add the entries now so that we get the correct size for
4907          the .dynamic section.  The DT_DEBUG entry is filled in by the
4908          dynamic linker and used by the debugger.  */
4909       if (! info->shared)
4910         {
4911           /* SGI object has the equivalence of DT_DEBUG in the
4912              DT_MIPS_RLD_MAP entry.  */
4913           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_MAP, 0))
4914             return false;
4915           if (!SGI_COMPAT (output_bfd))
4916             {
4917               if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4918                 return false;
4919             }
4920         }
4921       else
4922         {
4923           /* Shared libraries on traditional mips have DT_DEBUG.  */
4924           if (!SGI_COMPAT (output_bfd))
4925             {
4926               if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4927                 return false;
4928             }
4929         }
4930
4931       if (reltext && SGI_COMPAT (output_bfd))
4932         info->flags |= DF_TEXTREL;
4933
4934       if ((info->flags & DF_TEXTREL) != 0)
4935         {
4936           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
4937             return false;
4938         }
4939
4940       if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
4941         return false;
4942
4943       if (bfd_get_section_by_name (dynobj, "rel.dyn"))
4944         {
4945           if (! bfd_elf64_add_dynamic_entry (info, DT_REL, 0))
4946             return false;
4947
4948           if (! bfd_elf64_add_dynamic_entry (info, DT_RELSZ, 0))
4949             return false;
4950
4951           if (! bfd_elf64_add_dynamic_entry (info, DT_RELENT, 0))
4952             return false;
4953         }
4954
4955       if (SGI_COMPAT (output_bfd))
4956         {
4957           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICTNO, 0))
4958             return false;
4959         }
4960
4961       if (SGI_COMPAT (output_bfd))
4962         {
4963           if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLISTNO, 0))
4964             return false;
4965         }
4966
4967       if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
4968         {
4969           if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICT, 0))
4970             return false;
4971
4972           s = bfd_get_section_by_name (dynobj, ".liblist");
4973           BFD_ASSERT (s != NULL);
4974
4975           if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLIST, 0))
4976             return false;
4977         }
4978
4979       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_VERSION, 0))
4980         return false;
4981
4982       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_FLAGS, 0))
4983         return false;
4984
4985 #if 0
4986       /* Time stamps in executable files are a bad idea.  */
4987       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_TIME_STAMP, 0))
4988         return false;
4989 #endif
4990
4991 #if 0 /* FIXME  */
4992       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_ICHECKSUM, 0))
4993         return false;
4994 #endif
4995
4996 #if 0 /* FIXME  */
4997       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_IVERSION, 0))
4998         return false;
4999 #endif
5000
5001       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_BASE_ADDRESS, 0))
5002         return false;
5003
5004       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LOCAL_GOTNO, 0))
5005         return false;
5006
5007       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_SYMTABNO, 0))
5008         return false;
5009
5010       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_UNREFEXTNO, 0))
5011         return false;
5012
5013       if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_GOTSYM, 0))
5014         return false;
5015
5016       if ((bfd_get_section_by_name(dynobj, ".MIPS.options"))
5017           && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_OPTIONS, 0))
5018         return false;
5019
5020       if (bfd_get_section_by_name (dynobj, ".msym")
5021           && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_MSYM, 0))
5022         return false;
5023     }
5024
5025   return true;
5026 }
5027
5028 /* Finish up dynamic symbol handling.  We set the contents of various
5029    dynamic sections here.  */
5030
5031 boolean
5032 mips_elf64_finish_dynamic_symbol (output_bfd, info, h, sym)
5033      bfd *output_bfd;
5034      struct bfd_link_info *info;
5035      struct elf_link_hash_entry *h;
5036      Elf_Internal_Sym *sym;
5037 {
5038   bfd *dynobj;
5039   bfd_vma gval;
5040   asection *sgot;
5041   asection *smsym;
5042   struct mips_elf64_got_info *g;
5043   const char *name;
5044   struct mips_elf64_link_hash_entry *mh;
5045
5046   dynobj = elf_hash_table (info)->dynobj;
5047   gval = sym->st_value;
5048   mh = (struct mips_elf64_link_hash_entry *) h;
5049
5050   if (h->plt.offset != (bfd_vma) -1)
5051     {
5052       asection *s;
5053       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
5054
5055       /* This symbol has a stub.  Set it up.  */
5056
5057       BFD_ASSERT (h->dynindx != -1);
5058
5059       s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
5060       BFD_ASSERT (s != NULL);
5061
5062       /* FIXME: Can h->dynindex be more than 64K?  */
5063       if (h->dynindx & 0xffff0000)
5064         return false;
5065
5066       /* Fill the stub.  */
5067       bfd_put_32 (output_bfd, STUB_LW, stub);
5068       bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
5069       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
5070       bfd_put_32 (output_bfd, STUB_LI16 + h->dynindx, stub + 12);
5071
5072       BFD_ASSERT (h->plt.offset <= s->_raw_size);
5073       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
5074
5075       /* Mark the symbol as undefined.  plt.offset != -1 occurs
5076          only for the referenced symbol.  */
5077       sym->st_shndx = SHN_UNDEF;
5078
5079       /* The run-time linker uses the st_value field of the symbol
5080          to reset the global offset table entry for this external
5081          to its stub address when unlinking a shared object.  */
5082       gval = s->output_section->vma + s->output_offset + h->plt.offset;
5083       sym->st_value = gval;
5084     }
5085
5086   BFD_ASSERT (h->dynindx != -1
5087               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
5088
5089   sgot = bfd_get_section_by_name (dynobj, ".got");
5090   BFD_ASSERT (sgot != NULL);
5091   BFD_ASSERT (elf_section_data (sgot) != NULL);
5092   g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5093   BFD_ASSERT (g != NULL);
5094
5095   /* Run through the global symbol table, creating GOT entries for all
5096      the symbols that need them.  */
5097   if (g->global_gotsym != NULL
5098       && h->dynindx >= g->global_gotsym->dynindx)
5099     {
5100       bfd_vma offset;
5101       bfd_vma value;
5102
5103       if (sym->st_value)
5104         value = sym->st_value;
5105       else
5106         {
5107           /* For an entity defined in a shared object, this will be
5108              NULL.  (For functions in shared objects for
5109              which we have created stubs, ST_VALUE will be non-NULL.
5110              That's because such the functions are now no longer defined
5111              in a shared object.)  */
5112
5113           if (info->shared && h->root.type == bfd_link_hash_undefined)
5114             value = 0;
5115           else
5116             value = h->root.u.def.value;
5117         }
5118       offset = mips_elf64_global_got_index (dynobj, h);
5119       bfd_put_64 (output_bfd, value, sgot->contents + offset);
5120     }
5121
5122   /* Create a .msym entry, if appropriate.  */
5123   smsym = bfd_get_section_by_name (dynobj, ".msym");
5124   if (smsym)
5125     {
5126       Elf32_Internal_Msym msym;
5127
5128       msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
5129       /* It is undocumented what the `1' indicates, but IRIX6 uses
5130          this value.  */
5131       msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
5132       mips_elf64_swap_msym_out
5133         (dynobj, &msym,
5134          ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
5135     }
5136
5137   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5138   name = h->root.root.string;
5139   if (strcmp (name, "_DYNAMIC") == 0
5140       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
5141     sym->st_shndx = SHN_ABS;
5142   else if (strcmp (name, "_DYNAMIC_LINK") == 0
5143            || strcmp (name, "_DYNAMIC_LINKING") == 0)
5144     {
5145       sym->st_shndx = SHN_ABS;
5146       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5147       sym->st_value = 1;
5148     }
5149   else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
5150     {
5151       if (h->type == STT_FUNC)
5152         sym->st_shndx = SHN_MIPS_TEXT;
5153       else if (h->type == STT_OBJECT)
5154         sym->st_shndx = SHN_MIPS_DATA;
5155     }
5156
5157   /* Handle the IRIX6-specific symbols.  */
5158
5159     {
5160   /* The linker script takes care of providing names and values for
5161      these, but we must place them into the right sections.  */
5162   static const char* const text_section_symbols[] = {
5163     "_ftext",
5164     "_etext",
5165     "__dso_displacement",
5166     "__elf_header",
5167     "__program_header_table",
5168     NULL
5169   };
5170
5171   static const char* const data_section_symbols[] = {
5172     "_fdata",
5173     "_edata",
5174     "_end",
5175     "_fbss",
5176     NULL
5177   };
5178
5179   const char* const *p;
5180   int i;
5181
5182   for (i = 0; i < 2; ++i)
5183     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
5184          *p;
5185          ++p)
5186       if (strcmp (*p, name) == 0)
5187         {
5188           /* All of these symbols are given type STT_SECTION by the
5189              IRIX6 linker.  */
5190           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5191
5192           /* The IRIX linker puts these symbols in special sections.  */
5193           if (i == 0)
5194             sym->st_shndx = SHN_MIPS_TEXT;
5195           else
5196             sym->st_shndx = SHN_MIPS_DATA;
5197
5198           break;
5199         }
5200     }
5201
5202   return true;
5203 }
5204
5205 /* Finish up the dynamic sections.  */
5206
5207 boolean
5208 mips_elf64_finish_dynamic_sections (output_bfd, info)
5209      bfd *output_bfd;
5210      struct bfd_link_info *info;
5211 {
5212   bfd *dynobj;
5213   asection *sdyn;
5214   asection *sgot;
5215   struct mips_elf64_got_info *g;
5216
5217   dynobj = elf_hash_table (info)->dynobj;
5218
5219   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5220
5221   sgot = bfd_get_section_by_name (dynobj, ".got");
5222   if (sgot == NULL)
5223     g = NULL;
5224   else
5225     {
5226       BFD_ASSERT (elf_section_data (sgot) != NULL);
5227       g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5228       BFD_ASSERT (g != NULL);
5229     }
5230
5231   if (elf_hash_table (info)->dynamic_sections_created)
5232     {
5233       bfd_byte *b;
5234
5235       BFD_ASSERT (sdyn != NULL);
5236       BFD_ASSERT (g != NULL);
5237
5238       for (b = sdyn->contents;
5239            b < sdyn->contents + sdyn->_raw_size;
5240            b += get_elf_backend_data (dynobj)->s->sizeof_dyn)
5241         {
5242           Elf_Internal_Dyn dyn;
5243           const char *name;
5244           size_t elemsize;
5245           asection *s;
5246           boolean swap_out_p;
5247
5248           /* Read in the current dynamic entry.  */
5249           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
5250
5251           /* Assume that we're going to modify it and write it out.  */
5252           swap_out_p = true;
5253
5254           switch (dyn.d_tag)
5255             {
5256             case DT_RELENT:
5257               s = bfd_get_section_by_name(dynobj, "rel.dyn");
5258               BFD_ASSERT (s != NULL);
5259               dyn.d_un.d_val = get_elf_backend_data (dynobj)->s->sizeof_rel;
5260               break;
5261
5262             case DT_STRSZ:
5263               /* Rewrite DT_STRSZ.  */
5264               dyn.d_un.d_val =
5265                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5266               break;
5267
5268             case DT_PLTGOT:
5269               name = ".got";
5270               goto get_vma;
5271             case DT_MIPS_CONFLICT:
5272               name = ".conflict";
5273               goto get_vma;
5274             case DT_MIPS_LIBLIST:
5275               name = ".liblist";
5276             get_vma:
5277               s = bfd_get_section_by_name (output_bfd, name);
5278               BFD_ASSERT (s != NULL);
5279               dyn.d_un.d_ptr = s->vma;
5280               break;
5281
5282             case DT_MIPS_RLD_VERSION:
5283               dyn.d_un.d_val = 1; /* XXX */
5284               break;
5285
5286             case DT_MIPS_FLAGS:
5287               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
5288               break;
5289
5290             case DT_MIPS_CONFLICTNO:
5291               name = ".conflict";
5292               elemsize = sizeof (Elf32_Conflict);
5293               goto set_elemno;
5294
5295             case DT_MIPS_LIBLISTNO:
5296               name = ".liblist";
5297               elemsize = sizeof (Elf32_Lib);
5298             set_elemno:
5299               s = bfd_get_section_by_name (output_bfd, name);
5300               if (s != NULL)
5301                 {
5302                   if (s->_cooked_size != 0)
5303                     dyn.d_un.d_val = s->_cooked_size / elemsize;
5304                   else
5305                     dyn.d_un.d_val = s->_raw_size / elemsize;
5306                 }
5307               else
5308                 dyn.d_un.d_val = 0;
5309               break;
5310
5311             case DT_MIPS_TIME_STAMP:
5312               time ((time_t *) &dyn.d_un.d_val);
5313               break;
5314
5315             case DT_MIPS_ICHECKSUM:
5316               /* XXX FIXME: */
5317               swap_out_p = false;
5318               break;
5319
5320             case DT_MIPS_IVERSION:
5321               /* XXX FIXME: */
5322               swap_out_p = false;
5323               break;
5324
5325             case DT_MIPS_BASE_ADDRESS:
5326               s = output_bfd->sections;
5327               BFD_ASSERT (s != NULL);
5328               dyn.d_un.d_ptr = s->vma & ~(0xffff);
5329               break;
5330
5331             case DT_MIPS_LOCAL_GOTNO:
5332               dyn.d_un.d_val = g->local_gotno;
5333               break;
5334
5335             case DT_MIPS_UNREFEXTNO:
5336               /* The index into the dynamic symbol table which is the
5337                  entry of the first external symbol that is not
5338                  referenced within the same object.  */
5339               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
5340               break;
5341
5342             case DT_MIPS_GOTSYM:
5343               if (g->global_gotsym)
5344                 {
5345                   dyn.d_un.d_val = g->global_gotsym->dynindx;
5346                   break;
5347                 }
5348               /* In case if we don't have global got symbols we default
5349                  to setting DT_MIPS_GOTSYM to the same value as
5350                  DT_MIPS_SYMTABNO, so we just fall through.  */
5351
5352             case DT_MIPS_SYMTABNO:
5353               name = ".dynsym";
5354               elemsize = get_elf_backend_data (output_bfd)->s->sizeof_sym;
5355               s = bfd_get_section_by_name (output_bfd, name);
5356               BFD_ASSERT (s != NULL);
5357
5358               if (s->_cooked_size != 0)
5359                 dyn.d_un.d_val = s->_cooked_size / elemsize;
5360               else
5361                 dyn.d_un.d_val = s->_raw_size / elemsize;
5362               break;
5363
5364             case DT_MIPS_HIPAGENO:
5365               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
5366               break;
5367
5368             case DT_MIPS_OPTIONS:
5369               s = bfd_get_section_by_name(output_bfd, ".MIPS.options");
5370               dyn.d_un.d_ptr = s->vma;
5371               break;
5372
5373             case DT_MIPS_MSYM:
5374               s = bfd_get_section_by_name(output_bfd, ".msym");
5375               dyn.d_un.d_ptr = s->vma;
5376               break;
5377
5378             default:
5379               swap_out_p = false;
5380               break;
5381             }
5382
5383           if (swap_out_p)
5384             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
5385               (dynobj, &dyn, b);
5386         }
5387     }
5388
5389   /* The first entry of the global offset table will be filled at
5390      runtime. The second entry will be used by some runtime loaders.
5391      This isn't the case of Irix rld.  */
5392   if (sgot != NULL && sgot->_raw_size > 0)
5393     {
5394       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
5395       bfd_put_64 (output_bfd, (bfd_vma) 0x80000000, sgot->contents + 8);
5396     }
5397
5398   if (sgot != NULL)
5399     elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
5400
5401   {
5402     asection *smsym;
5403     asection *s;
5404
5405     /* ??? The section symbols for the output sections were set up in
5406        _bfd_elf_final_link.  SGI sets the STT_NOTYPE attribute for these
5407        symbols.  Should we do so?  */
5408
5409     smsym = bfd_get_section_by_name (dynobj, ".msym");
5410     if (smsym != NULL)
5411       {
5412         Elf32_Internal_Msym msym;
5413
5414         msym.ms_hash_value = 0;
5415         msym.ms_info = ELF32_MS_INFO (0, 1);
5416
5417         for (s = output_bfd->sections; s != NULL; s = s->next)
5418           {
5419             long dynindx = elf_section_data (s)->dynindx;
5420
5421             mips_elf64_swap_msym_out
5422               (output_bfd, &msym,
5423                (((Elf32_External_Msym *) smsym->contents)
5424                 + dynindx));
5425           }
5426       }
5427
5428     /* Clean up a first relocation in .rel.dyn.  */
5429     s = bfd_get_section_by_name (dynobj, "rel.dyn");
5430     if (s != NULL && s->_raw_size > 0)
5431       memset (s->contents, 0, get_elf_backend_data (dynobj)->s->sizeof_rel);
5432   }
5433
5434   return true;
5435 }
5436
5437 /* Return the section that should be marked against GC for a given
5438    relocation.  */
5439
5440 asection *
5441 mips_elf64_gc_mark_hook (abfd, info, rel, h, sym)
5442      bfd *abfd;
5443      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5444      Elf_Internal_Rela *rel;
5445      struct elf_link_hash_entry *h;
5446      Elf_Internal_Sym *sym;
5447 {
5448   if (h != NULL)
5449     {
5450       switch (ELF64_R_TYPE (rel->r_info))
5451         {
5452         case R_MIPS_GNU_VTINHERIT:
5453         case R_MIPS_GNU_VTENTRY:
5454           break;
5455
5456         default:
5457           switch (h->root.type)
5458             {
5459             case bfd_link_hash_defined:
5460             case bfd_link_hash_defweak:
5461               return h->root.u.def.section;
5462
5463             case bfd_link_hash_common:
5464               return h->root.u.c.p->section;
5465
5466             default:
5467               break;
5468             }
5469         }
5470     }
5471   else
5472     {
5473       return bfd_section_from_elf_index (abfd, sym->st_shndx);
5474     }
5475
5476   return NULL;
5477 }
5478
5479 /* Update the got entry reference counts for the section being removed.  */
5480
5481 boolean
5482 mips_elf64_gc_sweep_hook (abfd, info, sec, relocs)
5483      bfd *abfd ATTRIBUTE_UNUSED;
5484      struct bfd_link_info *info ATTRIBUTE_UNUSED;
5485      asection *sec ATTRIBUTE_UNUSED;
5486      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
5487 {
5488 #if 0
5489   Elf_Internal_Shdr *symtab_hdr;
5490   struct elf_link_hash_entry **sym_hashes;
5491   bfd_signed_vma *local_got_refcounts;
5492   const Elf_Internal_Rela *rel, *relend;
5493   unsigned long r_symndx;
5494   struct elf_link_hash_entry *h;
5495
5496   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5497   sym_hashes = elf_sym_hashes (abfd);
5498   local_got_refcounts = elf_local_got_refcounts (abfd);
5499
5500   relend = relocs + sec->reloc_count;
5501   for (rel = relocs; rel < relend; rel++)
5502     switch (ELF64_R_TYPE (rel->r_info))
5503       {
5504       case R_MIPS_GOT16:
5505       case R_MIPS_CALL16:
5506       case R_MIPS_CALL_HI16:
5507       case R_MIPS_CALL_LO16:
5508       case R_MIPS_GOT_HI16:
5509       case R_MIPS_GOT_LO16:
5510         /* ??? It would seem that the existing MIPS code does no sort
5511            of reference counting or whatnot on its GOT and PLT entries,
5512            so it is not possible to garbage collect them at this time.  */
5513         break;
5514
5515       default:
5516         break;
5517       }
5518 #endif
5519
5520   return true;
5521 }
5522 \f
5523 /* Create the .got section to hold the global offset table. */
5524
5525 static boolean
5526 mips_elf64_create_got_section (abfd, info)
5527      bfd *abfd;
5528      struct bfd_link_info *info;
5529 {
5530   flagword flags;
5531   register asection *s;
5532   struct elf_link_hash_entry *h;
5533   struct mips_elf64_got_info *g;
5534
5535   /* This function may be called more than once.  */
5536   if (bfd_get_section_by_name (abfd, ".got"))
5537     return true;
5538
5539   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5540            | SEC_LINKER_CREATED);
5541
5542   s = bfd_make_section (abfd, ".got");
5543   if (s == NULL
5544       || ! bfd_set_section_flags (abfd, s, flags)
5545       || ! bfd_set_section_alignment (abfd, s, 4))
5546     return false;
5547
5548   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
5549      linker script because we don't want to define the symbol if we
5550      are not creating a global offset table.  */
5551   h = NULL;
5552   if (! (_bfd_generic_link_add_one_symbol
5553          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5554           (bfd_vma) 0, (const char *) NULL, false,
5555           get_elf_backend_data (abfd)->collect,
5556           (struct bfd_link_hash_entry **) &h)))
5557     return false;
5558   h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
5559   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5560   h->type = STT_OBJECT;
5561
5562   if (info->shared
5563       && ! bfd_elf64_link_record_dynamic_symbol (info, h))
5564     return false;
5565
5566   /* The first several global offset table entries are reserved.  */
5567   s->_raw_size = MIPS_RESERVED_GOTNO * (get_elf_backend_data (abfd)->s->arch_size / 8);
5568
5569   g = (struct mips_elf64_got_info *) bfd_alloc (abfd,
5570                                           sizeof (struct mips_elf64_got_info));
5571   if (g == NULL)
5572     return false;
5573   g->global_gotsym = NULL;
5574   g->local_gotno = MIPS_RESERVED_GOTNO;
5575   g->assigned_gotno = MIPS_RESERVED_GOTNO;
5576   if (elf_section_data (s) == NULL)
5577     {
5578       s->used_by_bfd =
5579         (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
5580       if (elf_section_data (s) == NULL)
5581         return false;
5582     }
5583   elf_section_data (s)->tdata = (PTR) g;
5584   elf_section_data (s)->this_hdr.sh_flags
5585     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5586
5587   return true;
5588 }
5589
5590 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5591    symbol table index lower than any we've seen to date, record it for
5592    posterity.  */
5593
5594 static boolean
5595 mips_elf64_record_global_got_symbol (h, info, g)
5596      struct elf_link_hash_entry *h;
5597      struct bfd_link_info *info;
5598      struct mips_elf64_got_info *g ATTRIBUTE_UNUSED;
5599 {
5600   /* A global symbol in the GOT must also be in the dynamic symbol
5601      table.  */
5602   if (h->dynindx == -1
5603       && !bfd_elf64_link_record_dynamic_symbol (info, h))
5604     return false;
5605
5606   /* If we've already marked this entry as needing GOT space, we don't
5607      need to do it again.  */
5608   if (h->got.offset != (bfd_vma) - 1)
5609     return true;
5610
5611   /* By setting this to a value other than -1, we are indicating that
5612      there needs to be a GOT entry for H.  Avoid using zero, as the
5613      generic ELF copy_indirect_symbol tests for <= 0.  */
5614   h->got.offset = 1;
5615
5616   return true;
5617 }
5618
5619 /* Returns the .msym section for ABFD, creating it if it does not
5620    already exist.  Returns NULL to indicate error.  */
5621
5622 static asection *
5623 mips_elf64_create_msym_section (abfd)
5624      bfd *abfd;
5625 {
5626   asection *s;
5627
5628   s = bfd_get_section_by_name (abfd, ".msym");
5629   if (!s)
5630     {
5631       s = bfd_make_section (abfd, ".msym");
5632       if (!s
5633           || !bfd_set_section_flags (abfd, s,
5634                                      SEC_ALLOC
5635                                      | SEC_LOAD
5636                                      | SEC_HAS_CONTENTS
5637                                      | SEC_LINKER_CREATED
5638                                      | SEC_READONLY)
5639           || !bfd_set_section_alignment (abfd, s, 3))
5640         return NULL;
5641     }
5642
5643   return s;
5644 }
5645
5646 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
5647
5648 static void
5649 mips_elf64_allocate_dynamic_relocations (abfd, n)
5650      bfd *abfd;
5651      unsigned int n;
5652 {
5653   asection *s;
5654
5655   s = bfd_get_section_by_name (abfd, ".rel.dyn");
5656   BFD_ASSERT (s != NULL);
5657
5658   if (s->_raw_size == 0)
5659     {
5660       /* Make room for a null element. */
5661       s->_raw_size += get_elf_backend_data (abfd)->s->sizeof_rel;
5662       ++s->reloc_count;
5663     }
5664   s->_raw_size += n * get_elf_backend_data (abfd)->s->sizeof_rel;
5665 }
5666
5667 /* Look through the relocs for a section during the first phase, and
5668    allocate space in the global offset table.  */
5669
5670 boolean
5671 mips_elf64_check_relocs (abfd, info, sec, relocs)
5672      bfd *abfd;
5673      struct bfd_link_info *info;
5674      asection *sec;
5675      const Elf_Internal_Rela *relocs;
5676 {
5677   const char *name;
5678   bfd *dynobj;
5679   Elf_Internal_Shdr *symtab_hdr;
5680   struct elf_link_hash_entry **sym_hashes;
5681   struct mips_elf64_got_info *g;
5682   size_t extsymoff;
5683   const Elf_Internal_Rela *rel;
5684   const Elf_Internal_Rela *rel_end;
5685   asection *sgot;
5686   asection *sreloc;
5687   struct elf_backend_data *bed;
5688
5689   if (info->relocateable)
5690     return true;
5691
5692   dynobj = elf_hash_table (info)->dynobj;
5693   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5694   sym_hashes = elf_sym_hashes (abfd);
5695   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5696
5697   /* Check for the mips16 stub sections.  */
5698
5699   name = bfd_get_section_name (abfd, sec);
5700   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5701     {
5702       unsigned long r_symndx;
5703
5704       /* Look at the relocation information to figure out which symbol
5705          this is for.  */
5706
5707       r_symndx = ELF64_R_SYM (relocs->r_info);
5708
5709       if (r_symndx < extsymoff
5710           || sym_hashes[r_symndx - extsymoff] == NULL)
5711         {
5712           asection *o;
5713
5714           /* This stub is for a local symbol.  This stub will only be
5715              needed if there is some relocation in this BFD, other
5716              than a 16 bit function call, which refers to this symbol.  */
5717           for (o = abfd->sections; o != NULL; o = o->next)
5718             {
5719               Elf_Internal_Rela *sec_relocs;
5720               const Elf_Internal_Rela *r, *rend;
5721
5722               /* We can ignore stub sections when looking for relocs.  */
5723               if ((o->flags & SEC_RELOC) == 0
5724                   || o->reloc_count == 0
5725                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5726                               sizeof FN_STUB - 1) == 0
5727                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5728                               sizeof CALL_STUB - 1) == 0
5729                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5730                               sizeof CALL_FP_STUB - 1) == 0)
5731                 continue;
5732
5733               sec_relocs = (_bfd_elf64_link_read_relocs
5734                             (abfd, o, (PTR) NULL,
5735                              (Elf_Internal_Rela *) NULL,
5736                              info->keep_memory));
5737               if (sec_relocs == NULL)
5738                 return false;
5739
5740               rend = sec_relocs + o->reloc_count;
5741               for (r = sec_relocs; r < rend; r++)
5742                 if (ELF64_R_SYM (r->r_info) == r_symndx
5743                     && ELF64_R_TYPE (r->r_info) != R_MIPS16_26)
5744                   break;
5745
5746               if (! info->keep_memory)
5747                 free (sec_relocs);
5748
5749               if (r < rend)
5750                 break;
5751             }
5752
5753           if (o == NULL)
5754             {
5755               /* There is no non-call reloc for this stub, so we do
5756                  not need it.  Since this function is called before
5757                  the linker maps input sections to output sections, we
5758                  can easily discard it by setting the SEC_EXCLUDE
5759                  flag.  */
5760               sec->flags |= SEC_EXCLUDE;
5761               return true;
5762             }
5763
5764           /* Record this stub in an array of local symbol stubs for
5765              this BFD.  */
5766           if (elf_tdata (abfd)->local_stubs == NULL)
5767             {
5768               unsigned long symcount;
5769               asection **n;
5770               bfd_size_type amt;
5771
5772               if (elf_bad_symtab (abfd))
5773                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5774               else
5775                 symcount = symtab_hdr->sh_info;
5776               amt = symcount * sizeof (asection *);
5777               n = (asection **) bfd_zalloc (abfd, amt);
5778               if (n == NULL)
5779                 return false;
5780               elf_tdata (abfd)->local_stubs = n;
5781             }
5782
5783           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5784
5785           /* We don't need to set mips16_stubs_seen in this case.
5786              That flag is used to see whether we need to look through
5787              the global symbol table for stubs.  We don't need to set
5788              it here, because we just have a local stub.  */
5789         }
5790       else
5791         {
5792           struct mips_elf64_link_hash_entry *h;
5793
5794           h = ((struct mips_elf64_link_hash_entry *)
5795                sym_hashes[r_symndx - extsymoff]);
5796
5797           /* H is the symbol this stub is for.  */
5798
5799           h->fn_stub = sec;
5800           mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5801         }
5802     }
5803   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5804            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5805     {
5806       unsigned long r_symndx;
5807       struct mips_elf64_link_hash_entry *h;
5808       asection **loc;
5809
5810       /* Look at the relocation information to figure out which symbol
5811          this is for.  */
5812
5813       r_symndx = ELF64_R_SYM (relocs->r_info);
5814
5815       if (r_symndx < extsymoff
5816           || sym_hashes[r_symndx - extsymoff] == NULL)
5817         {
5818           /* This stub was actually built for a static symbol defined
5819              in the same file.  We assume that all static symbols in
5820              mips16 code are themselves mips16, so we can simply
5821              discard this stub.  Since this function is called before
5822              the linker maps input sections to output sections, we can
5823              easily discard it by setting the SEC_EXCLUDE flag.  */
5824           sec->flags |= SEC_EXCLUDE;
5825           return true;
5826         }
5827
5828       h = ((struct mips_elf64_link_hash_entry *)
5829            sym_hashes[r_symndx - extsymoff]);
5830
5831       /* H is the symbol this stub is for.  */
5832
5833       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5834         loc = &h->call_fp_stub;
5835       else
5836         loc = &h->call_stub;
5837
5838       /* If we already have an appropriate stub for this function, we
5839          don't need another one, so we can discard this one.  Since
5840          this function is called before the linker maps input sections
5841          to output sections, we can easily discard it by setting the
5842          SEC_EXCLUDE flag.  We can also discard this section if we
5843          happen to already know that this is a mips16 function; it is
5844          not necessary to check this here, as it is checked later, but
5845          it is slightly faster to check now.  */
5846       if (*loc != NULL || h->root.other == STO_MIPS16)
5847         {
5848           sec->flags |= SEC_EXCLUDE;
5849           return true;
5850         }
5851
5852       *loc = sec;
5853       mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5854     }
5855
5856   if (dynobj == NULL)
5857     {
5858       sgot = NULL;
5859       g = NULL;
5860     }
5861   else
5862     {
5863       sgot = bfd_get_section_by_name (dynobj, ".got");
5864       if (sgot == NULL)
5865         g = NULL;
5866       else
5867         {
5868           BFD_ASSERT (elf_section_data (sgot) != NULL);
5869           g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5870           BFD_ASSERT (g != NULL);
5871         }
5872     }
5873
5874   sreloc = NULL;
5875   bed = get_elf_backend_data (abfd);
5876   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5877   for (rel = relocs; rel < rel_end; ++rel)
5878     {
5879       unsigned long r_symndx;
5880       int r_type;
5881       struct elf_link_hash_entry *h;
5882
5883       r_symndx = ELF64_R_SYM (rel->r_info);
5884       r_type = ELF64_MIPS_R_TYPE (rel->r_info);
5885
5886       if (r_symndx < extsymoff)
5887         h = NULL;
5888       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5889         {
5890           (*_bfd_error_handler)
5891             (_("%s: Malformed reloc detected for section %s"),
5892              bfd_archive_filename (abfd), name);
5893           bfd_set_error (bfd_error_bad_value);
5894           return false;
5895         }
5896       else
5897         {
5898           h = sym_hashes[r_symndx - extsymoff];
5899
5900           /* This may be an indirect symbol created because of a version.  */
5901           if (h != NULL)
5902             {
5903               while (h->root.type == bfd_link_hash_indirect)
5904                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5905             }
5906         }
5907
5908       /* Some relocs require a global offset table.  */
5909       if (dynobj == NULL || sgot == NULL)
5910         {
5911           switch (r_type)
5912             {
5913             case R_MIPS_GOT16:
5914             case R_MIPS_CALL16:
5915             case R_MIPS_CALL_HI16:
5916             case R_MIPS_CALL_LO16:
5917             case R_MIPS_GOT_HI16:
5918             case R_MIPS_GOT_LO16:
5919             case R_MIPS_GOT_PAGE:
5920             case R_MIPS_GOT_OFST:
5921             case R_MIPS_GOT_DISP:
5922               if (dynobj == NULL)
5923                 elf_hash_table (info)->dynobj = dynobj = abfd;
5924               if (! mips_elf64_create_got_section (dynobj, info))
5925                 return false;
5926               g = _mips_elf64_got_info (dynobj, &sgot);
5927               break;
5928
5929             case R_MIPS_32:
5930             case R_MIPS_REL32:
5931             case R_MIPS_64:
5932               if (dynobj == NULL
5933                   && (info->shared || h != NULL)
5934                   && (sec->flags & SEC_ALLOC) != 0)
5935                 elf_hash_table (info)->dynobj = dynobj = abfd;
5936               break;
5937
5938             default:
5939               break;
5940             }
5941         }
5942
5943       if (!h && (r_type == R_MIPS_CALL_LO16
5944                  || r_type == R_MIPS_GOT_LO16
5945                  || r_type == R_MIPS_GOT_DISP))
5946         {
5947           /* We may need a local GOT entry for this relocation.  We
5948              don't count R_MIPS_GOT_PAGE because we can estimate the
5949              maximum number of pages needed by looking at the size of
5950              the segment.  Similar comments apply to R_MIPS_GOT16 and
5951              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5952              R_MIPS_CALL_HI16 because these are always followed by an
5953              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
5954
5955              This estimation is very conservative since we can merge
5956              duplicate entries in the GOT.  In order to be less
5957              conservative, we could actually build the GOT here,
5958              rather than in relocate_section.  */
5959           g->local_gotno++;
5960           sgot->_raw_size += get_elf_backend_data (dynobj)->s->arch_size / 8;
5961         }
5962
5963       switch (r_type)
5964         {
5965         case R_MIPS_CALL16:
5966           if (h == NULL)
5967             {
5968               (*_bfd_error_handler)
5969                 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5970                  bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5971               bfd_set_error (bfd_error_bad_value);
5972               return false;
5973             }
5974           /* Fall through.  */
5975
5976         case R_MIPS_CALL_HI16:
5977         case R_MIPS_CALL_LO16:
5978           if (h != NULL)
5979             {
5980               /* This symbol requires a global offset table entry.  */
5981               if (!mips_elf64_record_global_got_symbol (h, info, g))
5982                 return false;
5983
5984               /* We need a stub, not a plt entry for the undefined
5985                  function.  But we record it as if it needs plt.  See
5986                  elf_adjust_dynamic_symbol in elflink.h.  */
5987               h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5988               h->type = STT_FUNC;
5989             }
5990           break;
5991
5992         case R_MIPS_GOT16:
5993         case R_MIPS_GOT_HI16:
5994         case R_MIPS_GOT_LO16:
5995         case R_MIPS_GOT_DISP:
5996           /* This symbol requires a global offset table entry.  */
5997           if (h && !mips_elf64_record_global_got_symbol (h, info, g))
5998             return false;
5999           break;
6000
6001         case R_MIPS_32:
6002         case R_MIPS_REL32:
6003         case R_MIPS_64:
6004           if ((info->shared || h != NULL)
6005               && (sec->flags & SEC_ALLOC) != 0)
6006             {
6007               if (sreloc == NULL)
6008                 {
6009                   const char *name = ".rel.dyn";
6010
6011                   sreloc = bfd_get_section_by_name (dynobj, name);
6012                   if (sreloc == NULL)
6013                     {
6014                       sreloc = bfd_make_section (dynobj, name);
6015                       if (sreloc == NULL
6016                           || ! bfd_set_section_flags (dynobj, sreloc,
6017                                                       (SEC_ALLOC
6018                                                        | SEC_LOAD
6019                                                        | SEC_HAS_CONTENTS
6020                                                        | SEC_IN_MEMORY
6021                                                        | SEC_LINKER_CREATED
6022                                                        | SEC_READONLY))
6023                           || ! bfd_set_section_alignment (dynobj, sreloc,
6024                                                           4))
6025                         return false;
6026                     }
6027                 }
6028 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
6029               if (info->shared)
6030                 {
6031                   /* When creating a shared object, we must copy these
6032                      reloc types into the output file as R_MIPS_REL32
6033                      relocs.  We make room for this reloc in the
6034                      .rel.dyn reloc section.  */
6035                   mips_elf64_allocate_dynamic_relocations (dynobj, 1);
6036                   if ((sec->flags & MIPS_READONLY_SECTION)
6037                       == MIPS_READONLY_SECTION)
6038                     /* We tell the dynamic linker that there are
6039                        relocations against the text segment.  */
6040                     info->flags |= DF_TEXTREL;
6041                 }
6042               else
6043                 {
6044                   struct mips_elf64_link_hash_entry *hmips;
6045
6046                   /* We only need to copy this reloc if the symbol is
6047                      defined in a dynamic object.  */
6048                   hmips = (struct mips_elf64_link_hash_entry *) h;
6049                   ++hmips->possibly_dynamic_relocs;
6050                   if ((sec->flags & MIPS_READONLY_SECTION)
6051                       == MIPS_READONLY_SECTION)
6052                     /* We need it to tell the dynamic linker if there
6053                        are relocations against the text segment.  */
6054                     hmips->readonly_reloc = true;
6055                 }
6056
6057               /* Even though we don't directly need a GOT entry for
6058                  this symbol, a symbol must have a dynamic symbol
6059                  table index greater that DT_MIPS_GOTSYM if there are
6060                  dynamic relocations against it.  */
6061               if (h != NULL
6062                   && !mips_elf64_record_global_got_symbol (h, info, g))
6063                 return false;
6064             }
6065           break;
6066
6067         case R_MIPS_26:
6068         case R_MIPS_GPREL16:
6069         case R_MIPS_LITERAL:
6070         case R_MIPS_GPREL32:
6071           break;
6072
6073           /* This relocation describes the C++ object vtable hierarchy.
6074              Reconstruct it for later use during GC.  */
6075         case R_MIPS_GNU_VTINHERIT:
6076           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6077             return false;
6078           break;
6079
6080           /* This relocation describes which C++ vtable entries are actually
6081              used.  Record for later use during GC.  */
6082         case R_MIPS_GNU_VTENTRY:
6083           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6084             return false;
6085           break;
6086
6087         default:
6088           break;
6089         }
6090     }
6091
6092   return true;
6093 }
6094
6095 /* Structure used to pass information to mips_elf64_output_extsym.  */
6096
6097 struct extsym_info
6098 {
6099   bfd *abfd;
6100   struct bfd_link_info *info;
6101   struct ecoff_debug_info *debug;
6102   const struct ecoff_debug_swap *swap;
6103   boolean failed;
6104 };
6105
6106 /* This routine is used to write out ECOFF debugging external symbol
6107    information.  It is called via mips_elf64_link_hash_traverse.  The
6108    ECOFF external symbol information must match the ELF external
6109    symbol information.  Unfortunately, at this point we don't know
6110    whether a symbol is required by reloc information, so the two
6111    tables may wind up being different.  We must sort out the external
6112    symbol information before we can set the final size of the .mdebug
6113    section, and we must set the size of the .mdebug section before we
6114    can relocate any sections, and we can't know which symbols are
6115    required by relocation until we relocate the sections.
6116    Fortunately, it is relatively unlikely that any symbol will be
6117    stripped but required by a reloc.  In particular, it can not happen
6118    when generating a final executable.  */
6119
6120 static boolean
6121 mips_elf64_output_extsym (h, data)
6122      struct mips_elf64_link_hash_entry *h;
6123      PTR data;
6124 {
6125   struct extsym_info *einfo = (struct extsym_info *) data;
6126   boolean strip;
6127   asection *sec, *output_section;
6128
6129   if (h->root.indx == -2)
6130     strip = false;
6131   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
6132             || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
6133            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
6134            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
6135     strip = true;
6136   else if (einfo->info->strip == strip_all
6137            || (einfo->info->strip == strip_some
6138                && bfd_hash_lookup (einfo->info->keep_hash,
6139                                    h->root.root.root.string,
6140                                    false, false) == NULL))
6141     strip = true;
6142   else
6143     strip = false;
6144
6145   if (strip)
6146     return true;
6147
6148   if (h->esym.ifd == -2)
6149     {
6150       h->esym.jmptbl = 0;
6151       h->esym.cobol_main = 0;
6152       h->esym.weakext = 0;
6153       h->esym.reserved = 0;
6154       h->esym.ifd = ifdNil;
6155       h->esym.asym.value = 0;
6156       h->esym.asym.st = stGlobal;
6157
6158       if (h->root.root.type == bfd_link_hash_undefined
6159               || h->root.root.type == bfd_link_hash_undefweak)
6160         {
6161           const char *name;
6162
6163           /* Use undefined class.  Also, set class and type for some
6164              special symbols.  */
6165           name = h->root.root.root.string;
6166           h->esym.asym.sc = scUndefined;
6167         }
6168       else if (h->root.root.type != bfd_link_hash_defined
6169           && h->root.root.type != bfd_link_hash_defweak)
6170         h->esym.asym.sc = scAbs;
6171       else
6172         {
6173           const char *name;
6174
6175           sec = h->root.root.u.def.section;
6176           output_section = sec->output_section;
6177
6178           /* When making a shared library and symbol h is the one from
6179              the another shared library, OUTPUT_SECTION may be null.  */
6180           if (output_section == NULL)
6181             h->esym.asym.sc = scUndefined;
6182           else
6183             {
6184               name = bfd_section_name (output_section->owner, output_section);
6185
6186               if (strcmp (name, ".text") == 0)
6187                 h->esym.asym.sc = scText;
6188               else if (strcmp (name, ".data") == 0)
6189                 h->esym.asym.sc = scData;
6190               else if (strcmp (name, ".sdata") == 0)
6191                 h->esym.asym.sc = scSData;
6192               else if (strcmp (name, ".rodata") == 0
6193                        || strcmp (name, ".rdata") == 0)
6194                 h->esym.asym.sc = scRData;
6195               else if (strcmp (name, ".bss") == 0)
6196                 h->esym.asym.sc = scBss;
6197               else if (strcmp (name, ".sbss") == 0)
6198                 h->esym.asym.sc = scSBss;
6199               else if (strcmp (name, ".init") == 0)
6200                 h->esym.asym.sc = scInit;
6201               else if (strcmp (name, ".fini") == 0)
6202                 h->esym.asym.sc = scFini;
6203               else
6204                 h->esym.asym.sc = scAbs;
6205             }
6206         }
6207
6208       h->esym.asym.reserved = 0;
6209       h->esym.asym.index = indexNil;
6210     }
6211
6212   if (h->root.root.type == bfd_link_hash_common)
6213     h->esym.asym.value = h->root.root.u.c.size;
6214   else if (h->root.root.type == bfd_link_hash_defined
6215            || h->root.root.type == bfd_link_hash_defweak)
6216     {
6217       if (h->esym.asym.sc == scCommon)
6218         h->esym.asym.sc = scBss;
6219       else if (h->esym.asym.sc == scSCommon)
6220         h->esym.asym.sc = scSBss;
6221
6222       sec = h->root.root.u.def.section;
6223       output_section = sec->output_section;
6224       if (output_section != NULL)
6225         h->esym.asym.value = (h->root.root.u.def.value
6226                               + sec->output_offset
6227                               + output_section->vma);
6228       else
6229         h->esym.asym.value = 0;
6230     }
6231   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
6232     {
6233       struct mips_elf64_link_hash_entry *hd = h;
6234       boolean no_fn_stub = h->no_fn_stub;
6235
6236       while (hd->root.root.type == bfd_link_hash_indirect)
6237         {
6238           hd = (struct mips_elf64_link_hash_entry *)h->root.root.u.i.link;
6239           no_fn_stub = no_fn_stub || hd->no_fn_stub;
6240         }
6241
6242       if (!no_fn_stub)
6243         {
6244           /* Set type and value for a symbol with a function stub.  */
6245           h->esym.asym.st = stProc;
6246           sec = hd->root.root.u.def.section;
6247           if (sec == NULL)
6248             h->esym.asym.value = 0;
6249           else
6250             {
6251               output_section = sec->output_section;
6252               if (output_section != NULL)
6253                 h->esym.asym.value = (hd->root.plt.offset
6254                                       + sec->output_offset
6255                                       + output_section->vma);
6256               else
6257                 h->esym.asym.value = 0;
6258             }
6259 #if 0 /* FIXME?  */
6260           h->esym.ifd = 0;
6261 #endif
6262         }
6263     }
6264
6265   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
6266                                       h->root.root.root.string,
6267                                       &h->esym))
6268     {
6269       einfo->failed = true;
6270       return false;
6271     }
6272
6273   return true;
6274 }
6275
6276 /* Swap an entry in a .gptab section.  Note that these routines rely
6277    on the equivalence of the two elements of the union.  */
6278
6279 static void
6280 mips_elf64_swap_gptab_in (abfd, ex, in)
6281      bfd *abfd;
6282      const Elf32_External_gptab *ex;
6283      Elf32_gptab *in;
6284 {
6285   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
6286   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
6287 }
6288
6289 static void
6290 mips_elf64_swap_gptab_out (abfd, in, ex)
6291      bfd *abfd;
6292      const Elf32_gptab *in;
6293      Elf32_External_gptab *ex;
6294 {
6295   H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
6296                 ex->gt_entry.gt_g_value);
6297   H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
6298                 ex->gt_entry.gt_bytes);
6299 }
6300
6301 /* A comparison routine used to sort .gptab entries.  */
6302
6303 static int
6304 gptab_compare (p1, p2)
6305      const PTR p1;
6306      const PTR p2;
6307 {
6308   const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
6309   const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
6310
6311   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
6312 }
6313
6314 /* We need to use a special link routine to handle the .mdebug section.
6315    We need to merge all instances of this section together, not write
6316    them all out sequentially.  */
6317
6318 boolean
6319 mips_elf64_final_link (abfd, info)
6320      bfd *abfd;
6321      struct bfd_link_info *info;
6322 {
6323   asection **secpp;
6324   asection *o;
6325   struct bfd_link_order *p;
6326   asection *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
6327   struct ecoff_debug_info debug;
6328   const struct ecoff_debug_swap *swap
6329     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
6330   HDRR *symhdr = &debug.symbolic_header;
6331   PTR mdebug_handle = NULL;
6332   asection *s;
6333   EXTR esym;
6334   unsigned int i;
6335   static const char * const secname[] =
6336       { ".text", ".init", ".fini", ".data",
6337           ".rodata", ".sdata", ".sbss", ".bss" };
6338   static const int sc[] = { scText, scInit, scFini, scData,
6339                           scRData, scSData, scSBss, scBss };
6340
6341   /* If all the things we linked together were PIC, but we're
6342      producing an executable (rather than a shared object), then the
6343      resulting file is CPIC (i.e., it calls PIC code.)  */
6344   if (!info->shared
6345       && !info->relocateable
6346       && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
6347     {
6348       elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
6349       elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
6350     }
6351
6352   /* We'd carefully arranged the dynamic symbol indices, and then the
6353      generic size_dynamic_sections renumbered them out from under us.
6354      Rather than trying somehow to prevent the renumbering, just do
6355      the sort again.  */
6356   if (elf_hash_table (info)->dynamic_sections_created)
6357     {
6358       bfd *dynobj;
6359       asection *got;
6360       struct mips_elf64_got_info *g;
6361
6362       /* When we resort, we must tell mips_elf64_sort_hash_table what
6363          the lowest index it may use is.  That's the number of section
6364          symbols we're going to add.  The generic ELF linker only
6365          adds these symbols when building a shared object.  Note that
6366          we count the sections after (possibly) removing the .options
6367          section above.  */
6368       if (!mips_elf64_sort_hash_table (info, (info->shared
6369                                             ? bfd_count_sections (abfd) + 1
6370                                             : 1)))
6371         return false;
6372
6373       /* Make sure we didn't grow the global .got region.  */
6374       dynobj = elf_hash_table (info)->dynobj;
6375       got = bfd_get_section_by_name (dynobj, ".got");
6376       g = (struct mips_elf64_got_info *) elf_section_data (got)->tdata;
6377
6378       if (g->global_gotsym != NULL)
6379         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
6380                      - g->global_gotsym->dynindx)
6381                     <= g->global_gotno);
6382     }
6383
6384   /* We include .MIPS.options, even though we don't process it quite right.
6385      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
6386      to be better off including it than not.  */
6387   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
6388     {
6389       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
6390         {
6391           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
6392             if (p->type == bfd_indirect_link_order)
6393               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
6394           (*secpp)->link_order_head = NULL;
6395           bfd_section_list_remove (abfd, secpp);
6396           --abfd->section_count;
6397
6398           break;
6399         }
6400     }
6401
6402   /* Get a value for the GP register.  */
6403   if (elf_gp (abfd) == 0)
6404     {
6405       struct bfd_link_hash_entry *h;
6406
6407       h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
6408       if (h != (struct bfd_link_hash_entry *) NULL
6409           && h->type == bfd_link_hash_defined)
6410         elf_gp (abfd) = (h->u.def.value
6411                          + h->u.def.section->output_section->vma
6412                          + h->u.def.section->output_offset);
6413       else if (info->relocateable)
6414         {
6415           bfd_vma lo = MINUS_ONE;
6416
6417           /* Find the GP-relative section with the lowest offset.  */
6418           for (o = abfd->sections; o != NULL; o = o->next)
6419             if (o->vma < lo
6420                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
6421               lo = o->vma;
6422
6423           /* And calculate GP relative to that.  */
6424           elf_gp (abfd) = (lo + 0x7ff0);
6425         }
6426       else
6427         {
6428           /* If the relocate_section function needs to do a reloc
6429              involving the GP value, it should make a reloc_dangerous
6430              callback to warn that GP is not defined.  */
6431         }
6432     }
6433
6434   /* Go through the sections and collect the .mdebug information.  */
6435   mdebug_sec = NULL;
6436   gptab_data_sec = NULL;
6437   gptab_bss_sec = NULL;
6438   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
6439     {
6440       if (strcmp (o->name, ".mdebug") == 0)
6441         {
6442           struct extsym_info einfo;
6443           bfd_vma last;
6444
6445           /* We have found the .mdebug section in the output file.
6446              Look through all the link_orders comprising it and merge
6447              the information together.  */
6448           symhdr->magic = swap->sym_magic;
6449           /* FIXME: What should the version stamp be?  */
6450           symhdr->vstamp = 0;
6451           symhdr->ilineMax = 0;
6452           symhdr->cbLine = 0;
6453           symhdr->idnMax = 0;
6454           symhdr->ipdMax = 0;
6455           symhdr->isymMax = 0;
6456           symhdr->ioptMax = 0;
6457           symhdr->iauxMax = 0;
6458           symhdr->issMax = 0;
6459           symhdr->issExtMax = 0;
6460           symhdr->ifdMax = 0;
6461           symhdr->crfd = 0;
6462           symhdr->iextMax = 0;
6463
6464           /* We accumulate the debugging information itself in the
6465              debug_info structure.  */
6466           debug.line = NULL;
6467           debug.external_dnr = NULL;
6468           debug.external_pdr = NULL;
6469           debug.external_sym = NULL;
6470           debug.external_opt = NULL;
6471           debug.external_aux = NULL;
6472           debug.ss = NULL;
6473           debug.ssext = debug.ssext_end = NULL;
6474           debug.external_fdr = NULL;
6475           debug.external_rfd = NULL;
6476           debug.external_ext = debug.external_ext_end = NULL;
6477
6478           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
6479           if (mdebug_handle == (PTR) NULL)
6480             return false;
6481
6482           esym.jmptbl = 0;
6483           esym.cobol_main = 0;
6484           esym.weakext = 0;
6485           esym.reserved = 0;
6486           esym.ifd = ifdNil;
6487           esym.asym.iss = issNil;
6488           esym.asym.st = stLocal;
6489           esym.asym.reserved = 0;
6490           esym.asym.index = indexNil;
6491           last = 0;
6492           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
6493             {
6494               esym.asym.sc = sc[i];
6495               s = bfd_get_section_by_name (abfd, secname[i]);
6496               if (s != NULL)
6497                 {
6498                   esym.asym.value = s->vma;
6499                   last = s->vma + s->_raw_size;
6500                 }
6501               else
6502                 esym.asym.value = last;
6503               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
6504                                                  secname[i], &esym))
6505                 return false;
6506             }
6507
6508           for (p = o->link_order_head;
6509                p != (struct bfd_link_order *) NULL;
6510                p = p->next)
6511             {
6512               asection *input_section;
6513               bfd *input_bfd;
6514               const struct ecoff_debug_swap *input_swap;
6515               struct ecoff_debug_info input_debug;
6516               char *eraw_src;
6517               char *eraw_end;
6518
6519               if (p->type != bfd_indirect_link_order)
6520                 {
6521                   if (p->type == bfd_data_link_order)
6522                     continue;
6523                   abort ();
6524                 }
6525
6526               input_section = p->u.indirect.section;
6527               input_bfd = input_section->owner;
6528
6529               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
6530                   || (get_elf_backend_data (input_bfd)
6531                       ->elf_backend_ecoff_debug_swap) == NULL)
6532                 {
6533                   /* I don't know what a non MIPS ELF bfd would be
6534                      doing with a .mdebug section, but I don't really
6535                      want to deal with it.  */
6536                   continue;
6537                 }
6538
6539               input_swap = (get_elf_backend_data (input_bfd)
6540                             ->elf_backend_ecoff_debug_swap);
6541
6542               BFD_ASSERT (p->size == input_section->_raw_size);
6543
6544               /* The ECOFF linking code expects that we have already
6545                  read in the debugging information and set up an
6546                  ecoff_debug_info structure, so we do that now.  */
6547               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
6548                                                    &input_debug))
6549                 return false;
6550
6551               if (! (bfd_ecoff_debug_accumulate
6552                      (mdebug_handle, abfd, &debug, swap, input_bfd,
6553                       &input_debug, input_swap, info)))
6554                 return false;
6555
6556               /* Loop through the external symbols.  For each one with
6557                  interesting information, try to find the symbol in
6558                  the linker global hash table and save the information
6559                  for the output external symbols.  */
6560               eraw_src = input_debug.external_ext;
6561               eraw_end = (eraw_src
6562                           + (input_debug.symbolic_header.iextMax
6563                              * input_swap->external_ext_size));
6564               for (;
6565                    eraw_src < eraw_end;
6566                    eraw_src += input_swap->external_ext_size)
6567                 {
6568                   EXTR ext;
6569                   const char *name;
6570                   struct mips_elf64_link_hash_entry *h;
6571
6572                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
6573                   if (ext.asym.sc == scNil
6574                       || ext.asym.sc == scUndefined
6575                       || ext.asym.sc == scSUndefined)
6576                     continue;
6577
6578                   name = input_debug.ssext + ext.asym.iss;
6579                   h = mips_elf64_link_hash_lookup (mips_elf64_hash_table (info),
6580                                                  name, false, false, true);
6581                   if (h == NULL || h->esym.ifd != -2)
6582                     continue;
6583
6584                   if (ext.ifd != -1)
6585                     {
6586                       BFD_ASSERT (ext.ifd
6587                                   < input_debug.symbolic_header.ifdMax);
6588                       ext.ifd = input_debug.ifdmap[ext.ifd];
6589                     }
6590
6591                   h->esym = ext;
6592                 }
6593
6594               /* Free up the information we just read.  */
6595               free (input_debug.line);
6596               free (input_debug.external_dnr);
6597               free (input_debug.external_pdr);
6598               free (input_debug.external_sym);
6599               free (input_debug.external_opt);
6600               free (input_debug.external_aux);
6601               free (input_debug.ss);
6602               free (input_debug.ssext);
6603               free (input_debug.external_fdr);
6604               free (input_debug.external_rfd);
6605               free (input_debug.external_ext);
6606
6607               /* Hack: reset the SEC_HAS_CONTENTS flag so that
6608                  elf_link_input_bfd ignores this section.  */
6609               input_section->flags &=~ SEC_HAS_CONTENTS;
6610             }
6611
6612           /* Build the external symbol information.  */
6613           einfo.abfd = abfd;
6614           einfo.info = info;
6615           einfo.debug = &debug;
6616           einfo.swap = swap;
6617           einfo.failed = false;
6618           mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
6619                                        mips_elf64_output_extsym,
6620                                        (PTR) &einfo);
6621           if (einfo.failed)
6622             return false;
6623
6624           /* Set the size of the .mdebug section.  */
6625           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
6626
6627           /* Skip this section later on (I don't think this currently
6628              matters, but someday it might).  */
6629           o->link_order_head = (struct bfd_link_order *) NULL;
6630
6631           mdebug_sec = o;
6632         }
6633
6634       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
6635         {
6636           const char *subname;
6637           unsigned int c;
6638           Elf32_gptab *tab;
6639           Elf32_External_gptab *ext_tab;
6640           unsigned int i;
6641
6642           /* The .gptab.sdata and .gptab.sbss sections hold
6643              information describing how the small data area would
6644              change depending upon the -G switch.  These sections
6645              not used in executables files.  */
6646           if (! info->relocateable)
6647             {
6648               asection **secpp;
6649
6650               for (p = o->link_order_head;
6651                    p != (struct bfd_link_order *) NULL;
6652                    p = p->next)
6653                 {
6654                   asection *input_section;
6655
6656                   if (p->type != bfd_indirect_link_order)
6657                     {
6658                       if (p->type == bfd_data_link_order)
6659                         continue;
6660                       abort ();
6661                     }
6662
6663                   input_section = p->u.indirect.section;
6664
6665                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
6666                      elf_link_input_bfd ignores this section.  */
6667                   input_section->flags &=~ SEC_HAS_CONTENTS;
6668                 }
6669
6670               /* Skip this section later on (I don't think this
6671                  currently matters, but someday it might).  */
6672               o->link_order_head = (struct bfd_link_order *) NULL;
6673
6674               /* Really remove the section.  */
6675               for (secpp = &abfd->sections;
6676                    *secpp != o;
6677                    secpp = &(*secpp)->next)
6678                 ;
6679               bfd_section_list_remove (abfd, secpp);
6680               --abfd->section_count;
6681
6682               continue;
6683             }
6684
6685           /* There is one gptab for initialized data, and one for
6686              uninitialized data.  */
6687           if (strcmp (o->name, ".gptab.sdata") == 0)
6688             gptab_data_sec = o;
6689           else if (strcmp (o->name, ".gptab.sbss") == 0)
6690             gptab_bss_sec = o;
6691           else
6692             {
6693               (*_bfd_error_handler)
6694                 (_("%s: illegal section name `%s'"),
6695                  bfd_archive_filename (abfd), o->name);
6696               bfd_set_error (bfd_error_nonrepresentable_section);
6697               return false;
6698             }
6699
6700           /* The linker script always combines .gptab.data and
6701              .gptab.sdata into .gptab.sdata, and likewise for
6702              .gptab.bss and .gptab.sbss.  It is possible that there is
6703              no .sdata or .sbss section in the output file, in which
6704              case we must change the name of the output section.  */
6705           subname = o->name + sizeof ".gptab" - 1;
6706           if (bfd_get_section_by_name (abfd, subname) == NULL)
6707             {
6708               if (o == gptab_data_sec)
6709                 o->name = ".gptab.data";
6710               else
6711                 o->name = ".gptab.bss";
6712               subname = o->name + sizeof ".gptab" - 1;
6713               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
6714             }
6715
6716           /* Set up the first entry.  */
6717           c = 1;
6718           tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
6719           if (tab == NULL)
6720             return false;
6721           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
6722           tab[0].gt_header.gt_unused = 0;
6723
6724           /* Combine the input sections.  */
6725           for (p = o->link_order_head;
6726                p != (struct bfd_link_order *) NULL;
6727                p = p->next)
6728             {
6729               asection *input_section;
6730               bfd *input_bfd;
6731               bfd_size_type size;
6732               unsigned long last;
6733               bfd_size_type gpentry;
6734
6735               if (p->type != bfd_indirect_link_order)
6736                 {
6737                   if (p->type == bfd_data_link_order)
6738                     continue;
6739                   abort ();
6740                 }
6741
6742               input_section = p->u.indirect.section;
6743               input_bfd = input_section->owner;
6744
6745               /* Combine the gptab entries for this input section one
6746                  by one.  We know that the input gptab entries are
6747                  sorted by ascending -G value.  */
6748               size = bfd_section_size (input_bfd, input_section);
6749               last = 0;
6750               for (gpentry = sizeof (Elf32_External_gptab);
6751                    gpentry < size;
6752                    gpentry += sizeof (Elf32_External_gptab))
6753                 {
6754                   Elf32_External_gptab ext_gptab;
6755                   Elf32_gptab int_gptab;
6756                   unsigned long val;
6757                   unsigned long add;
6758                   boolean exact;
6759                   unsigned int look;
6760
6761                   if (! (bfd_get_section_contents
6762                          (input_bfd, input_section, (PTR) &ext_gptab,
6763                           gpentry, sizeof (Elf32_External_gptab))))
6764                     {
6765                       free (tab);
6766                       return false;
6767                     }
6768
6769                   mips_elf64_swap_gptab_in (input_bfd, &ext_gptab,
6770                                                 &int_gptab);
6771                   val = int_gptab.gt_entry.gt_g_value;
6772                   add = int_gptab.gt_entry.gt_bytes - last;
6773
6774                   exact = false;
6775                   for (look = 1; look < c; look++)
6776                     {
6777                       if (tab[look].gt_entry.gt_g_value >= val)
6778                         tab[look].gt_entry.gt_bytes += add;
6779
6780                       if (tab[look].gt_entry.gt_g_value == val)
6781                         exact = true;
6782                     }
6783
6784                   if (! exact)
6785                     {
6786                       Elf32_gptab *new_tab;
6787                       unsigned int max;
6788
6789                       /* We need a new table entry.  */
6790                       new_tab = ((Elf32_gptab *)
6791                                  bfd_realloc ((PTR) tab,
6792                                               (c + 1) * sizeof (Elf32_gptab)));
6793                       if (new_tab == NULL)
6794                         {
6795                           free (tab);
6796                           return false;
6797                         }
6798                       tab = new_tab;
6799                       tab[c].gt_entry.gt_g_value = val;
6800                       tab[c].gt_entry.gt_bytes = add;
6801
6802                       /* Merge in the size for the next smallest -G
6803                          value, since that will be implied by this new
6804                          value.  */
6805                       max = 0;
6806                       for (look = 1; look < c; look++)
6807                         {
6808                           if (tab[look].gt_entry.gt_g_value < val
6809                               && (max == 0
6810                                   || (tab[look].gt_entry.gt_g_value
6811                                       > tab[max].gt_entry.gt_g_value)))
6812                             max = look;
6813                         }
6814                       if (max != 0)
6815                         tab[c].gt_entry.gt_bytes +=
6816                           tab[max].gt_entry.gt_bytes;
6817
6818                       ++c;
6819                     }
6820
6821                   last = int_gptab.gt_entry.gt_bytes;
6822                 }
6823
6824               /* Hack: reset the SEC_HAS_CONTENTS flag so that
6825                  elf_link_input_bfd ignores this section.  */
6826               input_section->flags &=~ SEC_HAS_CONTENTS;
6827             }
6828
6829           /* The table must be sorted by -G value.  */
6830           if (c > 2)
6831             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
6832
6833           /* Swap out the table.  */
6834           ext_tab = ((Elf32_External_gptab *)
6835                      bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
6836           if (ext_tab == NULL)
6837             {
6838               free (tab);
6839               return false;
6840             }
6841
6842           for (i = 0; i < c; i++)
6843             mips_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
6844           free (tab);
6845
6846           o->_raw_size = c * sizeof (Elf32_External_gptab);
6847           o->contents = (bfd_byte *) ext_tab;
6848
6849           /* Skip this section later on (I don't think this currently
6850              matters, but someday it might).  */
6851           o->link_order_head = (struct bfd_link_order *) NULL;
6852         }
6853     }
6854
6855   /* Invoke the regular ELF backend linker to do all the work.  */
6856   if (!bfd_elf64_bfd_final_link (abfd, info))
6857      return false;
6858
6859   /* Now write out the computed sections.  */
6860   if (mdebug_sec != (asection *) NULL)
6861     {
6862       BFD_ASSERT (abfd->output_has_begun);
6863       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
6864                                                swap, info,
6865                                                mdebug_sec->filepos))
6866         return false;
6867
6868       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
6869     }
6870   if (gptab_data_sec != (asection *) NULL)
6871     {
6872       if (! bfd_set_section_contents (abfd, gptab_data_sec,
6873                                       gptab_data_sec->contents,
6874                                       (file_ptr) 0,
6875                                       gptab_data_sec->_raw_size))
6876         return false;
6877     }
6878
6879   if (gptab_bss_sec != (asection *) NULL)
6880     {
6881       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
6882                                       gptab_bss_sec->contents,
6883                                       (file_ptr) 0,
6884                                       gptab_bss_sec->_raw_size))
6885         return false;
6886     }
6887
6888   return true;
6889 }
6890 \f
6891 /* ECOFF swapping routines.  These are used when dealing with the
6892    .mdebug section, which is in the ECOFF debugging format.  */
6893 static const struct ecoff_debug_swap mips_elf64_ecoff_debug_swap =
6894 {
6895   /* Symbol table magic number.  */
6896   magicSym2,
6897   /* Alignment of debugging information.  E.g., 4.  */
6898   8,
6899   /* Sizes of external symbolic information.  */
6900   sizeof (struct hdr_ext),
6901   sizeof (struct dnr_ext),
6902   sizeof (struct pdr_ext),
6903   sizeof (struct sym_ext),
6904   sizeof (struct opt_ext),
6905   sizeof (struct fdr_ext),
6906   sizeof (struct rfd_ext),
6907   sizeof (struct ext_ext),
6908   /* Functions to swap in external symbolic data.  */
6909   ecoff_swap_hdr_in,
6910   ecoff_swap_dnr_in,
6911   ecoff_swap_pdr_in,
6912   ecoff_swap_sym_in,
6913   ecoff_swap_opt_in,
6914   ecoff_swap_fdr_in,
6915   ecoff_swap_rfd_in,
6916   ecoff_swap_ext_in,
6917   _bfd_ecoff_swap_tir_in,
6918   _bfd_ecoff_swap_rndx_in,
6919   /* Functions to swap out external symbolic data.  */
6920   ecoff_swap_hdr_out,
6921   ecoff_swap_dnr_out,
6922   ecoff_swap_pdr_out,
6923   ecoff_swap_sym_out,
6924   ecoff_swap_opt_out,
6925   ecoff_swap_fdr_out,
6926   ecoff_swap_rfd_out,
6927   ecoff_swap_ext_out,
6928   _bfd_ecoff_swap_tir_out,
6929   _bfd_ecoff_swap_rndx_out,
6930   /* Function to read in symbolic data.  */
6931   _bfd_mips_elf_read_ecoff_info
6932 };
6933 \f
6934 /* Relocations in the 64 bit MIPS ELF ABI are more complex than in
6935    standard ELF.  This structure is used to redirect the relocation
6936    handling routines.  */
6937
6938 const struct elf_size_info mips_elf64_size_info =
6939 {
6940   sizeof (Elf64_External_Ehdr),
6941   sizeof (Elf64_External_Phdr),
6942   sizeof (Elf64_External_Shdr),
6943   sizeof (Elf64_Mips_External_Rel),
6944   sizeof (Elf64_Mips_External_Rela),
6945   sizeof (Elf64_External_Sym),
6946   sizeof (Elf64_External_Dyn),
6947   sizeof (Elf_External_Note),
6948   4,            /* hash-table entry size */
6949   3,            /* internal relocations per external relocations */
6950   64,           /* arch_size */
6951   8,            /* file_align */
6952   ELFCLASS64,
6953   EV_CURRENT,
6954   bfd_elf64_write_out_phdrs,
6955   bfd_elf64_write_shdrs_and_ehdr,
6956   mips_elf64_write_relocs,
6957   bfd_elf64_swap_symbol_out,
6958   mips_elf64_slurp_reloc_table,
6959   bfd_elf64_slurp_symbol_table,
6960   bfd_elf64_swap_dyn_in,
6961   bfd_elf64_swap_dyn_out,
6962   mips_elf64_be_swap_reloc_in,
6963   mips_elf64_be_swap_reloc_out,
6964   mips_elf64_be_swap_reloca_in,
6965   mips_elf64_be_swap_reloca_out
6966 };
6967
6968 #define ELF_ARCH                        bfd_arch_mips
6969 #define ELF_MACHINE_CODE                EM_MIPS
6970
6971 #define ELF_MAXPAGESIZE                 0x1000
6972
6973 #define elf_backend_collect             true
6974 #define elf_backend_type_change_ok      true
6975 #define elf_backend_can_gc_sections     true
6976 #define elf_info_to_howto               mips_elf64_info_to_howto_rela
6977 #define elf_info_to_howto_rel           mips_elf64_info_to_howto_rel
6978 #define elf_backend_object_p            _bfd_mips_elf_object_p
6979 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
6980 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
6981 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
6982 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
6983 #define elf_backend_section_from_bfd_section \
6984                                         _bfd_mips_elf_section_from_bfd_section
6985 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
6986 #define elf_backend_link_output_symbol_hook \
6987                                         _bfd_mips_elf_link_output_symbol_hook
6988 #define elf_backend_create_dynamic_sections \
6989                                         mips_elf64_create_dynamic_sections
6990 #define elf_backend_check_relocs        mips_elf64_check_relocs
6991 #define elf_backend_adjust_dynamic_symbol \
6992                                         mips_elf64_adjust_dynamic_symbol
6993 #define elf_backend_always_size_sections \
6994                                         mips_elf64_always_size_sections
6995 #define elf_backend_size_dynamic_sections \
6996                                         mips_elf64_size_dynamic_sections
6997 #define elf_backend_relocate_section    mips_elf64_relocate_section
6998 #define elf_backend_finish_dynamic_symbol \
6999                                         mips_elf64_finish_dynamic_symbol
7000 #define elf_backend_finish_dynamic_sections \
7001                                         mips_elf64_finish_dynamic_sections
7002 #define elf_backend_final_write_processing \
7003                                         _bfd_mips_elf_final_write_processing
7004 #define elf_backend_additional_program_headers \
7005                                         mips_elf64_additional_program_headers
7006 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
7007 #define elf_backend_gc_mark_hook        mips_elf64_gc_mark_hook
7008 #define elf_backend_gc_sweep_hook       mips_elf64_gc_sweep_hook
7009 #define elf_backend_ecoff_debug_swap    &mips_elf64_ecoff_debug_swap
7010 #define elf_backend_size_info           mips_elf64_size_info
7011
7012 #define elf_backend_got_header_size     (4 * MIPS_RESERVED_GOTNO)
7013 #define elf_backend_plt_header_size     0
7014
7015 /* MIPS ELF64 can use a mixture of REL and RELA, but some Relocations
7016  * work better/work only in RELA, so we default to this.  */
7017 #define elf_backend_may_use_rel_p       1
7018 #define elf_backend_may_use_rela_p      1
7019 #define elf_backend_default_use_rela_p  1
7020
7021 /* We don't set bfd_elf64_bfd_is_local_label_name because the 32-bit
7022    MIPS-specific function only applies to IRIX5, which had no 64-bit
7023    ABI.  */
7024 #define bfd_elf64_find_nearest_line     _bfd_mips_elf_find_nearest_line
7025 #define bfd_elf64_set_section_contents  _bfd_mips_elf_set_section_contents
7026 #define bfd_elf64_bfd_link_hash_table_create \
7027                                         mips_elf64_link_hash_table_create
7028 #define bfd_elf64_bfd_final_link        mips_elf64_final_link
7029 #define bfd_elf64_bfd_merge_private_bfd_data \
7030                                         _bfd_mips_elf_merge_private_bfd_data
7031 #define bfd_elf64_bfd_set_private_flags _bfd_mips_elf_set_private_flags
7032 #define bfd_elf64_bfd_print_private_bfd_data \
7033                                         _bfd_mips_elf_print_private_bfd_data
7034
7035 #define bfd_elf64_get_reloc_upper_bound mips_elf64_get_reloc_upper_bound
7036 #define bfd_elf64_bfd_reloc_type_lookup mips_elf64_reloc_type_lookup
7037 #define bfd_elf64_archive_functions
7038 extern boolean bfd_elf64_archive_slurp_armap
7039   PARAMS((bfd *));
7040 extern boolean bfd_elf64_archive_write_armap
7041   PARAMS((bfd *, unsigned int, struct orl *, unsigned int, int));
7042 #define bfd_elf64_archive_slurp_extended_name_table \
7043                                 _bfd_archive_coff_slurp_extended_name_table
7044 #define bfd_elf64_archive_construct_extended_name_table \
7045                                 _bfd_archive_coff_construct_extended_name_table
7046 #define bfd_elf64_archive_truncate_arname \
7047                                         _bfd_archive_coff_truncate_arname
7048 #define bfd_elf64_archive_read_ar_hdr   _bfd_archive_coff_read_ar_hdr
7049 #define bfd_elf64_archive_openr_next_archived_file \
7050                                 _bfd_archive_coff_openr_next_archived_file
7051 #define bfd_elf64_archive_get_elt_at_index \
7052                                         _bfd_archive_coff_get_elt_at_index
7053 #define bfd_elf64_archive_generic_stat_arch_elt \
7054                                         _bfd_archive_coff_generic_stat_arch_elt
7055 #define bfd_elf64_archive_update_armap_timestamp \
7056                                 _bfd_archive_coff_update_armap_timestamp
7057
7058 /* The SGI style (n)64 NewABI.  */
7059 #define TARGET_LITTLE_SYM               bfd_elf64_littlemips_vec
7060 #define TARGET_LITTLE_NAME              "elf64-littlemips"
7061 #define TARGET_BIG_SYM                  bfd_elf64_bigmips_vec
7062 #define TARGET_BIG_NAME                 "elf64-bigmips"
7063
7064 #include "elf64-target.h"
7065
7066 #define INCLUDED_TARGET_FILE            /* More a type of flag.  */
7067
7068 /* The SYSV-style 'traditional' (n)64 NewABI.  */
7069 #undef TARGET_LITTLE_SYM
7070 #undef TARGET_LITTLE_NAME
7071 #undef TARGET_BIG_SYM
7072 #undef TARGET_BIG_NAME
7073
7074 #define TARGET_LITTLE_SYM               bfd_elf64_tradlittlemips_vec
7075 #define TARGET_LITTLE_NAME              "elf64-tradlittlemips"
7076 #define TARGET_BIG_SYM                  bfd_elf64_tradbigmips_vec
7077 #define TARGET_BIG_NAME                 "elf64-tradbigmips"
7078
7079 /* Include the target file again for this target.  */
7080 #include "elf64-target.h"