bfd/elf32-mips.c

   1 /* MIPS-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003 Free Software Foundation, Inc.
   4
   5    Most of the information added by Ian Lance Taylor, Cygnus Support,
   6    <ian@cygnus.com>.
   7    N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
   8    <mark@codesourcery.com>
   9    Traditional MIPS targets support added by Koundinya.K, Dansk Data
  10    Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
  11
  12 This file is part of BFD, the Binary File Descriptor library.
  13
  14 This program is free software; you can redistribute it and/or modify
  15 it under the terms of the GNU General Public License as published by
  16 the Free Software Foundation; either version 2 of the License, or
  17 (at your option) any later version.
  18
  19 This program is distributed in the hope that it will be useful,
  20 but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 GNU General Public License for more details.
  23
  24 You should have received a copy of the GNU General Public License
  25 along with this program; if not, write to the Free Software
  26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 /* This file handles MIPS ELF targets.  SGI Irix 5 uses a slightly
  29    different MIPS ELF from other targets.  This matters when linking.
  30    This file supports both, switching at runtime.  */
  31
  32 #include "bfd.h"
  33 #include "sysdep.h"
  34 #include "libbfd.h"
  35 #include "bfdlink.h"
  36 #include "genlink.h"
  37 #include "elf-bfd.h"
  38 #include "elfxx-mips.h"
  39 #include "elf/mips.h"
  40
  41 /* Get the ECOFF swapping routines.  */
  42 #include "coff/sym.h"
  43 #include "coff/symconst.h"
  44 #include "coff/internal.h"
  45 #include "coff/ecoff.h"
  46 #include "coff/mips.h"
  47 #define ECOFF_SIGNED_32
  48 #include "ecoffswap.h"
  49
  50 static bfd_reloc_status_type mips_elf_hi16_reloc
  51   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  52 static bfd_reloc_status_type mips_elf_lo16_reloc
  53   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  54 static bfd_reloc_status_type mips_elf_got16_reloc
  55   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  56 static bfd_reloc_status_type mips_elf_gprel32_reloc
  57   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  58 static bfd_reloc_status_type mips32_64bit_reloc
  59   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  60 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  61   PARAMS ((bfd *, bfd_reloc_code_real_type));
  62 static reloc_howto_type *mips_elf32_rtype_to_howto
  63   PARAMS ((unsigned int, bfd_boolean));
  64 static void mips_info_to_howto_rel
  65   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  66 static void mips_info_to_howto_rela
  67   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  68 static bfd_boolean mips_elf_sym_is_global
  69   PARAMS ((bfd *, asymbol *));
  70 static bfd_boolean mips_elf32_object_p
  71   PARAMS ((bfd *));
  72 static bfd_boolean mips_elf_is_local_label_name
  73   PARAMS ((bfd *, const char *));
  74 static bfd_reloc_status_type mips16_jump_reloc
  75   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  76 static bfd_reloc_status_type mips16_gprel_reloc
  77   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  78 static bfd_reloc_status_type mips_elf_final_gp
  79   PARAMS ((bfd *, asymbol *, bfd_boolean, char **, bfd_vma *));
  80 static bfd_boolean mips_elf_assign_gp
  81   PARAMS ((bfd *, bfd_vma *));
  82 static bfd_boolean elf32_mips_grok_prstatus
  83   PARAMS ((bfd *, Elf_Internal_Note *));
  84 static bfd_boolean elf32_mips_grok_psinfo
  85   PARAMS ((bfd *, Elf_Internal_Note *));
  86 static irix_compat_t elf32_mips_irix_compat
  87   PARAMS ((bfd *));
  88
  89 extern const bfd_target bfd_elf32_bigmips_vec;
  90 extern const bfd_target bfd_elf32_littlemips_vec;
  91
  92 /* Nonzero if ABFD is using the N32 ABI.  */
  93 #define ABI_N32_P(abfd) \
  94   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
  95
  96 /* Whether we are trying to be compatible with IRIX at all.  */
  97 #define SGI_COMPAT(abfd) \
  98   (elf32_mips_irix_compat (abfd) != ict_none)
  99
 100 /* The number of local .got entries we reserve.  */
 101 #define MIPS_RESERVED_GOTNO (2)
 102
 103 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 104    from smaller values.  Start with zero, widen, *then* decrement.  */
 105 #define MINUS_ONE       (((bfd_vma)0) - 1)
 106
 107 /* The relocation table used for SHT_REL sections.  */
 108
 109 static reloc_howto_type elf_mips_howto_table_rel[] =
 110 {
 111   /* No relocation.  */
 112   HOWTO (R_MIPS_NONE,           /* type */
 113          0,                     /* rightshift */
 114          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 115          0,                     /* bitsize */
 116          FALSE,                 /* pc_relative */
 117          0,                     /* bitpos */
 118          complain_overflow_dont, /* complain_on_overflow */
 119          bfd_elf_generic_reloc, /* special_function */
 120          "R_MIPS_NONE",         /* name */
 121          FALSE,                 /* partial_inplace */
 122          0,                     /* src_mask */
 123          0,                     /* dst_mask */
 124          FALSE),                /* pcrel_offset */
 125
 126   /* 16 bit relocation.  */
 127   HOWTO (R_MIPS_16,             /* type */
 128          0,                     /* rightshift */
 129          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 130          16,                    /* bitsize */
 131          FALSE,                 /* pc_relative */
 132          0,                     /* bitpos */
 133          complain_overflow_signed, /* complain_on_overflow */
 134          bfd_elf_generic_reloc, /* special_function */
 135          "R_MIPS_16",           /* name */
 136          TRUE,                  /* partial_inplace */
 137          0x0000ffff,            /* src_mask */
 138          0x0000ffff,            /* dst_mask */
 139          FALSE),                /* pcrel_offset */
 140
 141   /* 32 bit relocation.  */
 142   HOWTO (R_MIPS_32,             /* type */
 143          0,                     /* rightshift */
 144          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 145          32,                    /* bitsize */
 146          FALSE,                 /* pc_relative */
 147          0,                     /* bitpos */
 148          complain_overflow_dont, /* complain_on_overflow */
 149          bfd_elf_generic_reloc, /* special_function */
 150          "R_MIPS_32",           /* name */
 151          TRUE,                  /* partial_inplace */
 152          0xffffffff,            /* src_mask */
 153          0xffffffff,            /* dst_mask */
 154          FALSE),                /* pcrel_offset */
 155
 156   /* 32 bit symbol relative relocation.  */
 157   HOWTO (R_MIPS_REL32,          /* type */
 158          0,                     /* rightshift */
 159          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 160          32,                    /* bitsize */
 161          FALSE,                 /* pc_relative */
 162          0,                     /* bitpos */
 163          complain_overflow_dont, /* complain_on_overflow */
 164          bfd_elf_generic_reloc, /* special_function */
 165          "R_MIPS_REL32",        /* name */
 166          TRUE,                  /* partial_inplace */
 167          0xffffffff,            /* src_mask */
 168          0xffffffff,            /* dst_mask */
 169          FALSE),                /* pcrel_offset */
 170
 171   /* 26 bit jump address.  */
 172   HOWTO (R_MIPS_26,             /* type */
 173          2,                     /* rightshift */
 174          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          26,                    /* bitsize */
 176          FALSE,                 /* pc_relative */
 177          0,                     /* bitpos */
 178          complain_overflow_dont, /* complain_on_overflow */
 179                                 /* This needs complex overflow
 180                                    detection, because the upper four
 181                                    bits must match the PC + 4.  */
 182          bfd_elf_generic_reloc, /* special_function */
 183          "R_MIPS_26",           /* name */
 184          TRUE,                  /* partial_inplace */
 185          0x03ffffff,            /* src_mask */
 186          0x03ffffff,            /* dst_mask */
 187          FALSE),                /* pcrel_offset */
 188
 189   /* High 16 bits of symbol value.  */
 190   HOWTO (R_MIPS_HI16,           /* type */
 191          0,                     /* rightshift */
 192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 193          16,                    /* bitsize */
 194          FALSE,                 /* pc_relative */
 195          0,                     /* bitpos */
 196          complain_overflow_dont, /* complain_on_overflow */
 197          mips_elf_hi16_reloc,   /* special_function */
 198          "R_MIPS_HI16",         /* name */
 199          TRUE,                  /* partial_inplace */
 200          0x0000ffff,            /* src_mask */
 201          0x0000ffff,            /* dst_mask */
 202          FALSE),                /* pcrel_offset */
 203
 204   /* Low 16 bits of symbol value.  */
 205   HOWTO (R_MIPS_LO16,           /* type */
 206          0,                     /* rightshift */
 207          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 208          16,                    /* bitsize */
 209          FALSE,                 /* pc_relative */
 210          0,                     /* bitpos */
 211          complain_overflow_dont, /* complain_on_overflow */
 212          mips_elf_lo16_reloc,   /* special_function */
 213          "R_MIPS_LO16",         /* name */
 214          TRUE,                  /* partial_inplace */
 215          0x0000ffff,            /* src_mask */
 216          0x0000ffff,            /* dst_mask */
 217          FALSE),                /* pcrel_offset */
 218
 219   /* GP relative reference.  */
 220   HOWTO (R_MIPS_GPREL16,        /* type */
 221          0,                     /* rightshift */
 222          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 223          16,                    /* bitsize */
 224          FALSE,                 /* pc_relative */
 225          0,                     /* bitpos */
 226          complain_overflow_signed, /* complain_on_overflow */
 227          _bfd_mips_elf32_gprel16_reloc, /* special_function */
 228          "R_MIPS_GPREL16",      /* name */
 229          TRUE,                  /* partial_inplace */
 230          0x0000ffff,            /* src_mask */
 231          0x0000ffff,            /* dst_mask */
 232          FALSE),                /* pcrel_offset */
 233
 234   /* Reference to literal section.  */
 235   HOWTO (R_MIPS_LITERAL,        /* type */
 236          0,                     /* rightshift */
 237          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 238          16,                    /* bitsize */
 239          FALSE,                 /* pc_relative */
 240          0,                     /* bitpos */
 241          complain_overflow_signed, /* complain_on_overflow */
 242          _bfd_mips_elf32_gprel16_reloc, /* special_function */
 243          "R_MIPS_LITERAL",      /* name */
 244          TRUE,                  /* partial_inplace */
 245          0x0000ffff,            /* src_mask */
 246          0x0000ffff,            /* dst_mask */
 247          FALSE),                /* pcrel_offset */
 248
 249   /* Reference to global offset table.  */
 250   HOWTO (R_MIPS_GOT16,          /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          16,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_signed, /* complain_on_overflow */
 257          mips_elf_got16_reloc,  /* special_function */
 258          "R_MIPS_GOT16",        /* name */
 259          TRUE,                  /* partial_inplace */
 260          0x0000ffff,            /* src_mask */
 261          0x0000ffff,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   /* 16 bit PC relative reference.  */
 265   HOWTO (R_MIPS_PC16,           /* type */
 266          0,                     /* rightshift */
 267          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          16,                    /* bitsize */
 269          TRUE,                  /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_signed, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_MIPS_PC16",         /* name */
 274          TRUE,                  /* partial_inplace */
 275          0x0000ffff,            /* src_mask */
 276          0x0000ffff,            /* dst_mask */
 277          TRUE),                 /* pcrel_offset */
 278
 279   /* 16 bit call through global offset table.  */
 280   HOWTO (R_MIPS_CALL16,         /* type */
 281          0,                     /* rightshift */
 282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          16,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_signed, /* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_MIPS_CALL16",       /* name */
 289          TRUE,                  /* partial_inplace */
 290          0x0000ffff,            /* src_mask */
 291          0x0000ffff,            /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* 32 bit GP relative reference.  */
 295   HOWTO (R_MIPS_GPREL32,        /* type */
 296          0,                     /* rightshift */
 297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          32,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_dont, /* complain_on_overflow */
 302          mips_elf_gprel32_reloc, /* special_function */
 303          "R_MIPS_GPREL32",      /* name */
 304          TRUE,                  /* partial_inplace */
 305          0xffffffff,            /* src_mask */
 306          0xffffffff,            /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* The remaining relocs are defined on Irix 5, although they are
 310      not defined by the ABI.  */
 311   EMPTY_HOWTO (13),
 312   EMPTY_HOWTO (14),
 313   EMPTY_HOWTO (15),
 314
 315   /* A 5 bit shift field.  */
 316   HOWTO (R_MIPS_SHIFT5,         /* type */
 317          0,                     /* rightshift */
 318          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          5,                     /* bitsize */
 320          FALSE,                 /* pc_relative */
 321          6,                     /* bitpos */
 322          complain_overflow_bitfield, /* complain_on_overflow */
 323          bfd_elf_generic_reloc, /* special_function */
 324          "R_MIPS_SHIFT5",       /* name */
 325          TRUE,                  /* partial_inplace */
 326          0x000007c0,            /* src_mask */
 327          0x000007c0,            /* dst_mask */
 328          FALSE),                /* pcrel_offset */
 329
 330   /* A 6 bit shift field.  */
 331   /* FIXME: This is not handled correctly; a special function is
 332      needed to put the most significant bit in the right place.  */
 333   HOWTO (R_MIPS_SHIFT6,         /* type */
 334          0,                     /* rightshift */
 335          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 336          6,                     /* bitsize */
 337          FALSE,                 /* pc_relative */
 338          6,                     /* bitpos */
 339          complain_overflow_bitfield, /* complain_on_overflow */
 340          bfd_elf_generic_reloc, /* special_function */
 341          "R_MIPS_SHIFT6",       /* name */
 342          TRUE,                  /* partial_inplace */
 343          0x000007c4,            /* src_mask */
 344          0x000007c4,            /* dst_mask */
 345          FALSE),                /* pcrel_offset */
 346
 347   /* A 64 bit relocation.  */
 348   HOWTO (R_MIPS_64,             /* type */
 349          0,                     /* rightshift */
 350          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 351          64,                    /* bitsize */
 352          FALSE,                 /* pc_relative */
 353          0,                     /* bitpos */
 354          complain_overflow_dont, /* complain_on_overflow */
 355          mips32_64bit_reloc,    /* special_function */
 356          "R_MIPS_64",           /* name */
 357          TRUE,                  /* partial_inplace */
 358          MINUS_ONE,             /* src_mask */
 359          MINUS_ONE,             /* dst_mask */
 360          FALSE),                /* pcrel_offset */
 361
 362   /* Displacement in the global offset table.  */
 363   HOWTO (R_MIPS_GOT_DISP,       /* 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          bfd_elf_generic_reloc, /* special_function */
 371          "R_MIPS_GOT_DISP",     /* name */
 372          TRUE,                  /* partial_inplace */
 373          0x0000ffff,            /* src_mask */
 374          0x0000ffff,            /* dst_mask */
 375          FALSE),                /* pcrel_offset */
 376
 377   /* Displacement to page pointer in the global offset table.  */
 378   HOWTO (R_MIPS_GOT_PAGE,       /* 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          bfd_elf_generic_reloc, /* special_function */
 386          "R_MIPS_GOT_PAGE",     /* name */
 387          TRUE,                  /* partial_inplace */
 388          0x0000ffff,            /* src_mask */
 389          0x0000ffff,            /* dst_mask */
 390          FALSE),                /* pcrel_offset */
 391
 392   /* Offset from page pointer in the global offset table.  */
 393   HOWTO (R_MIPS_GOT_OFST,       /* 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          bfd_elf_generic_reloc, /* special_function */
 401          "R_MIPS_GOT_OFST",     /* name */
 402          TRUE,                  /* partial_inplace */
 403          0x0000ffff,            /* src_mask */
 404          0x0000ffff,            /* dst_mask */
 405          FALSE),                /* pcrel_offset */
 406
 407   /* High 16 bits of displacement in global offset table.  */
 408   HOWTO (R_MIPS_GOT_HI16,       /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          FALSE,                 /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_dont, /* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* special_function */
 416          "R_MIPS_GOT_HI16",     /* name */
 417          TRUE,                  /* partial_inplace */
 418          0x0000ffff,            /* src_mask */
 419          0x0000ffff,            /* dst_mask */
 420          FALSE),                /* pcrel_offset */
 421
 422   /* Low 16 bits of displacement in global offset table.  */
 423   HOWTO (R_MIPS_GOT_LO16,       /* type */
 424          0,                     /* rightshift */
 425          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 426          16,                    /* bitsize */
 427          FALSE,                 /* pc_relative */
 428          0,                     /* bitpos */
 429          complain_overflow_dont, /* complain_on_overflow */
 430          bfd_elf_generic_reloc, /* special_function */
 431          "R_MIPS_GOT_LO16",     /* name */
 432          TRUE,                  /* partial_inplace */
 433          0x0000ffff,            /* src_mask */
 434          0x0000ffff,            /* dst_mask */
 435          FALSE),                /* pcrel_offset */
 436
 437   /* 64 bit subtraction.  Used in the N32 ABI.  */
 438   HOWTO (R_MIPS_SUB,            /* type */
 439          0,                     /* rightshift */
 440          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 441          64,                    /* bitsize */
 442          FALSE,                 /* pc_relative */
 443          0,                     /* bitpos */
 444          complain_overflow_dont, /* complain_on_overflow */
 445          bfd_elf_generic_reloc, /* special_function */
 446          "R_MIPS_SUB",          /* name */
 447          TRUE,                  /* partial_inplace */
 448          MINUS_ONE,             /* src_mask */
 449          MINUS_ONE,             /* dst_mask */
 450          FALSE),                /* pcrel_offset */
 451
 452   /* Used to cause the linker to insert and delete instructions?  */
 453   EMPTY_HOWTO (R_MIPS_INSERT_A),
 454   EMPTY_HOWTO (R_MIPS_INSERT_B),
 455   EMPTY_HOWTO (R_MIPS_DELETE),
 456
 457   /* Get the higher value of a 64 bit addend.  */
 458   HOWTO (R_MIPS_HIGHER,         /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          FALSE,                 /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_dont, /* complain_on_overflow */
 465          bfd_elf_generic_reloc, /* special_function */
 466          "R_MIPS_HIGHER",       /* name */
 467          TRUE,                  /* partial_inplace */
 468          0x0000ffff,            /* src_mask */
 469          0x0000ffff,            /* dst_mask */
 470          FALSE),                /* pcrel_offset */
 471
 472   /* Get the highest value of a 64 bit addend.  */
 473   HOWTO (R_MIPS_HIGHEST,        /* type */
 474          0,                     /* rightshift */
 475          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          16,                    /* bitsize */
 477          FALSE,                 /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_dont, /* complain_on_overflow */
 480          bfd_elf_generic_reloc, /* special_function */
 481          "R_MIPS_HIGHEST",      /* name */
 482          TRUE,                  /* partial_inplace */
 483          0x0000ffff,            /* src_mask */
 484          0x0000ffff,            /* dst_mask */
 485          FALSE),                /* pcrel_offset */
 486
 487   /* High 16 bits of displacement in global offset table.  */
 488   HOWTO (R_MIPS_CALL_HI16,      /* type */
 489          0,                     /* rightshift */
 490          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 491          16,                    /* 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_CALL_HI16",    /* name */
 497          TRUE,                  /* partial_inplace */
 498          0x0000ffff,            /* src_mask */
 499          0x0000ffff,            /* dst_mask */
 500          FALSE),                /* pcrel_offset */
 501
 502   /* Low 16 bits of displacement in global offset table.  */
 503   HOWTO (R_MIPS_CALL_LO16,      /* type */
 504          0,                     /* rightshift */
 505          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          16,                    /* bitsize */
 507          FALSE,                 /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_dont, /* complain_on_overflow */
 510          bfd_elf_generic_reloc, /* special_function */
 511          "R_MIPS_CALL_LO16",    /* name */
 512          TRUE,                  /* partial_inplace */
 513          0x0000ffff,            /* src_mask */
 514          0x0000ffff,            /* dst_mask */
 515          FALSE),                /* pcrel_offset */
 516
 517   /* Section displacement.  */
 518   HOWTO (R_MIPS_SCN_DISP,       /* type */
 519          0,                     /* rightshift */
 520          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 521          32,                    /* bitsize */
 522          FALSE,                 /* pc_relative */
 523          0,                     /* bitpos */
 524          complain_overflow_dont, /* complain_on_overflow */
 525          bfd_elf_generic_reloc, /* special_function */
 526          "R_MIPS_SCN_DISP",     /* name */
 527          TRUE,                  /* partial_inplace */
 528          0xffffffff,            /* src_mask */
 529          0xffffffff,            /* dst_mask */
 530          FALSE),                /* pcrel_offset */
 531
 532   EMPTY_HOWTO (R_MIPS_REL16),
 533   EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
 534   EMPTY_HOWTO (R_MIPS_PJUMP),
 535   EMPTY_HOWTO (R_MIPS_RELGOT),
 536
 537   /* Protected jump conversion.  This is an optimization hint.  No
 538      relocation is required for correctness.  */
 539   HOWTO (R_MIPS_JALR,           /* type */
 540          0,                     /* rightshift */
 541          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          32,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_dont, /* complain_on_overflow */
 546          bfd_elf_generic_reloc, /* special_function */
 547          "R_MIPS_JALR",         /* name */
 548          FALSE,                 /* partial_inplace */
 549          0x00000000,            /* src_mask */
 550          0x00000000,            /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552 };
 553
 554 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link.  This
 555    is a hack to make the linker think that we need 64 bit values.  */
 556 static reloc_howto_type elf_mips_ctor64_howto =
 557   HOWTO (R_MIPS_64,             /* type */
 558          0,                     /* rightshift */
 559          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 560          32,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_signed, /* complain_on_overflow */
 564          mips32_64bit_reloc,    /* special_function */
 565          "R_MIPS_64",           /* name */
 566          TRUE,                  /* partial_inplace */
 567          0xffffffff,            /* src_mask */
 568          0xffffffff,            /* dst_mask */
 569          FALSE);                /* pcrel_offset */
 570
 571 /* The reloc used for the mips16 jump instruction.  */
 572 static reloc_howto_type elf_mips16_jump_howto =
 573   HOWTO (R_MIPS16_26,           /* type */
 574          2,                     /* rightshift */
 575          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 576          26,                    /* bitsize */
 577          FALSE,                 /* pc_relative */
 578          0,                     /* bitpos */
 579          complain_overflow_dont, /* complain_on_overflow */
 580                                 /* This needs complex overflow
 581                                    detection, because the upper four
 582                                    bits must match the PC.  */
 583          mips16_jump_reloc,     /* special_function */
 584          "R_MIPS16_26",         /* name */
 585          TRUE,                  /* partial_inplace */
 586          0x3ffffff,             /* src_mask */
 587          0x3ffffff,             /* dst_mask */
 588          FALSE);                /* pcrel_offset */
 589
 590 /* The reloc used for the mips16 gprel instruction.  */
 591 static reloc_howto_type elf_mips16_gprel_howto =
 592   HOWTO (R_MIPS16_GPREL,        /* type */
 593          0,                     /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          16,                    /* bitsize */
 596          FALSE,                 /* pc_relative */
 597          0,                     /* bitpos */
 598          complain_overflow_signed, /* complain_on_overflow */
 599          mips16_gprel_reloc,    /* special_function */
 600          "R_MIPS16_GPREL",      /* name */
 601          TRUE,                  /* partial_inplace */
 602          0x07ff001f,            /* src_mask */
 603          0x07ff001f,            /* dst_mask */
 604          FALSE);                /* pcrel_offset */
 605
 606 /* GNU extensions for embedded-pic.  */
 607 /* High 16 bits of symbol value, pc-relative.  */
 608 static reloc_howto_type elf_mips_gnu_rel_hi16 =
 609   HOWTO (R_MIPS_GNU_REL_HI16,   /* type */
 610          0,                     /* rightshift */
 611          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 612          16,                    /* bitsize */
 613          TRUE,                  /* pc_relative */
 614          0,                     /* bitpos */
 615          complain_overflow_dont, /* complain_on_overflow */
 616          mips_elf_hi16_reloc,   /* special_function */
 617          "R_MIPS_GNU_REL_HI16", /* name */
 618          TRUE,                  /* partial_inplace */
 619          0xffff,                /* src_mask */
 620          0xffff,                /* dst_mask */
 621          TRUE);                 /* pcrel_offset */
 622
 623 /* Low 16 bits of symbol value, pc-relative.  */
 624 static reloc_howto_type elf_mips_gnu_rel_lo16 =
 625   HOWTO (R_MIPS_GNU_REL_LO16,   /* type */
 626          0,                     /* rightshift */
 627          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 628          16,                    /* bitsize */
 629          TRUE,                  /* pc_relative */
 630          0,                     /* bitpos */
 631          complain_overflow_dont, /* complain_on_overflow */
 632          mips_elf_lo16_reloc,   /* special_function */
 633          "R_MIPS_GNU_REL_LO16", /* name */
 634          TRUE,                  /* partial_inplace */
 635          0xffff,                /* src_mask */
 636          0xffff,                /* dst_mask */
 637          TRUE);                 /* pcrel_offset */
 638
 639 /* 16 bit offset for pc-relative branches.  */
 640 static reloc_howto_type elf_mips_gnu_rel16_s2 =
 641   HOWTO (R_MIPS_GNU_REL16_S2,   /* type */
 642          2,                     /* rightshift */
 643          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 644          16,                    /* bitsize */
 645          TRUE,                  /* pc_relative */
 646          0,                     /* bitpos */
 647          complain_overflow_signed, /* complain_on_overflow */
 648          bfd_elf_generic_reloc, /* special_function */
 649          "R_MIPS_GNU_REL16_S2", /* name */
 650          TRUE,                  /* partial_inplace */
 651          0xffff,                /* src_mask */
 652          0xffff,                /* dst_mask */
 653          TRUE);                 /* pcrel_offset */
 654
 655 /* 64 bit pc-relative.  */
 656 static reloc_howto_type elf_mips_gnu_pcrel64 =
 657   HOWTO (R_MIPS_PC64,           /* type */
 658          0,                     /* rightshift */
 659          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          64,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_MIPS_PC64",         /* name */
 666          TRUE,                  /* partial_inplace */
 667          MINUS_ONE,             /* src_mask */
 668          MINUS_ONE,             /* dst_mask */
 669          TRUE);                 /* pcrel_offset */
 670
 671 /* 32 bit pc-relative.  */
 672 static reloc_howto_type elf_mips_gnu_pcrel32 =
 673   HOWTO (R_MIPS_PC32,           /* type */
 674          0,                     /* rightshift */
 675          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          32,                    /* bitsize */
 677          TRUE,                  /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_signed, /* complain_on_overflow */
 680          bfd_elf_generic_reloc, /* special_function */
 681          "R_MIPS_PC32",         /* name */
 682          TRUE,                  /* partial_inplace */
 683          0xffffffff,            /* src_mask */
 684          0xffffffff,            /* dst_mask */
 685          TRUE);                 /* pcrel_offset */
 686
 687 /* GNU extension to record C++ vtable hierarchy */
 688 static reloc_howto_type elf_mips_gnu_vtinherit_howto =
 689   HOWTO (R_MIPS_GNU_VTINHERIT,  /* type */
 690          0,                     /* rightshift */
 691          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 692          0,                     /* bitsize */
 693          FALSE,                 /* pc_relative */
 694          0,                     /* bitpos */
 695          complain_overflow_dont, /* complain_on_overflow */
 696          NULL,                  /* special_function */
 697          "R_MIPS_GNU_VTINHERIT", /* name */
 698          FALSE,                 /* partial_inplace */
 699          0,                     /* src_mask */
 700          0,                     /* dst_mask */
 701          FALSE);                /* pcrel_offset */
 702
 703 /* GNU extension to record C++ vtable member usage */
 704 static reloc_howto_type elf_mips_gnu_vtentry_howto =
 705   HOWTO (R_MIPS_GNU_VTENTRY,    /* type */
 706          0,                     /* rightshift */
 707          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          0,                     /* bitsize */
 709          FALSE,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_dont, /* complain_on_overflow */
 712          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 713          "R_MIPS_GNU_VTENTRY",  /* name */
 714          FALSE,                 /* partial_inplace */
 715          0,                     /* src_mask */
 716          0,                     /* dst_mask */
 717          FALSE);                /* pcrel_offset */
 718
 719 /* Do a R_MIPS_HI16 relocation.  This has to be done in combination
 720    with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
 721    the HI16.  Here we just save the information we need; we do the
 722    actual relocation when we see the LO16.
 723
 724    MIPS ELF requires that the LO16 immediately follow the HI16.  As a
 725    GNU extension, for non-pc-relative relocations, we permit an
 726    arbitrary number of HI16 relocs to be associated with a single LO16
 727    reloc.  This extension permits gcc to output the HI and LO relocs
 728    itself.
 729
 730    This cannot be done for PC-relative relocations because both the HI16
 731    and LO16 parts of the relocations must be done relative to the LO16
 732    part, and there can be carry to or borrow from the HI16 part.  */
 733
 734 struct mips_hi16
 735 {
 736   struct mips_hi16 *next;
 737   bfd_byte *addr;
 738   bfd_vma addend;
 739 };
 740
 741 /* FIXME: This should not be a static variable.  */
 742
 743 static struct mips_hi16 *mips_hi16_list;
 744
 745 static bfd_reloc_status_type
 746 mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data, input_section,
 747                      output_bfd, error_message)
 748      bfd *abfd ATTRIBUTE_UNUSED;
 749      arelent *reloc_entry;
 750      asymbol *symbol;
 751      PTR data;
 752      asection *input_section;
 753      bfd *output_bfd;
 754      char **error_message;
 755 {
 756   bfd_reloc_status_type ret;
 757   bfd_vma relocation;
 758   struct mips_hi16 *n;
 759
 760   /* If we're relocating, and this is an external symbol, we don't want
 761      to change anything.  */
 762   if (output_bfd != (bfd *) NULL
 763       && (symbol->flags & BSF_SECTION_SYM) == 0
 764       && reloc_entry->addend == 0)
 765     {
 766       reloc_entry->address += input_section->output_offset;
 767       return bfd_reloc_ok;
 768     }
 769
 770   ret = bfd_reloc_ok;
 771
 772   if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
 773     {
 774       bfd_boolean relocateable;
 775       bfd_vma gp;
 776
 777       if (ret == bfd_reloc_undefined)
 778         abort ();
 779
 780       if (output_bfd != NULL)
 781         relocateable = TRUE;
 782       else
 783         {
 784           relocateable = FALSE;
 785           output_bfd = symbol->section->output_section->owner;
 786         }
 787
 788       ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
 789                                error_message, &gp);
 790       if (ret != bfd_reloc_ok)
 791         return ret;
 792
 793       relocation = gp - reloc_entry->address;
 794     }
 795   else
 796     {
 797       if (bfd_is_und_section (symbol->section)
 798           && output_bfd == (bfd *) NULL)
 799         ret = bfd_reloc_undefined;
 800
 801       if (bfd_is_com_section (symbol->section))
 802         relocation = 0;
 803       else
 804         relocation = symbol->value;
 805     }
 806
 807   relocation += symbol->section->output_section->vma;
 808   relocation += symbol->section->output_offset;
 809   relocation += reloc_entry->addend;
 810
 811   if (reloc_entry->address > input_section->_cooked_size)
 812     return bfd_reloc_outofrange;
 813
 814   /* Save the information, and let LO16 do the actual relocation.  */
 815   n = (struct mips_hi16 *) bfd_malloc ((bfd_size_type) sizeof *n);
 816   if (n == NULL)
 817     return bfd_reloc_outofrange;
 818   n->addr = (bfd_byte *) data + reloc_entry->address;
 819   n->addend = relocation;
 820   n->next = mips_hi16_list;
 821   mips_hi16_list = n;
 822
 823   if (output_bfd != (bfd *) NULL)
 824     reloc_entry->address += input_section->output_offset;
 825
 826   return ret;
 827 }
 828
 829 /* Do a R_MIPS_LO16 relocation.  This is a straightforward 16 bit
 830    inplace relocation; this function exists in order to do the
 831    R_MIPS_HI16 relocation described above.  */
 832
 833 static bfd_reloc_status_type
 834 mips_elf_lo16_reloc (abfd, reloc_entry, symbol, data, input_section,
 835                      output_bfd, error_message)
 836      bfd *abfd;
 837      arelent *reloc_entry;
 838      asymbol *symbol;
 839      PTR data;
 840      asection *input_section;
 841      bfd *output_bfd;
 842      char **error_message;
 843 {
 844   arelent gp_disp_relent;
 845
 846   if (mips_hi16_list != NULL)
 847     {
 848       struct mips_hi16 *l;
 849
 850       l = mips_hi16_list;
 851       while (l != NULL)
 852         {
 853           unsigned long insn;
 854           unsigned long val;
 855           unsigned long vallo;
 856           struct mips_hi16 *next;
 857
 858           /* Do the HI16 relocation.  Note that we actually don't need
 859              to know anything about the LO16 itself, except where to
 860              find the low 16 bits of the addend needed by the LO16.  */
 861           insn = bfd_get_32 (abfd, l->addr);
 862           vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 863
 864           /* The low order 16 bits are always treated as a signed
 865              value.  */
 866           vallo = ((vallo & 0xffff) ^ 0x8000) - 0x8000;
 867           val = ((insn & 0xffff) << 16) + vallo;
 868           val += l->addend;
 869
 870           /* If PC-relative, we need to subtract out the address of the LO
 871              half of the HI/LO.  (The actual relocation is relative
 872              to that instruction.)  */
 873           if (reloc_entry->howto->pc_relative)
 874             val -= reloc_entry->address;
 875
 876           /* At this point, "val" has the value of the combined HI/LO
 877              pair.  If the low order 16 bits (which will be used for
 878              the LO16 insn) are negative, then we will need an
 879              adjustment for the high order 16 bits.  */
 880           val += 0x8000;
 881           val = (val >> 16) & 0xffff;
 882
 883           insn &= ~ (bfd_vma) 0xffff;
 884           insn |= val;
 885           bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
 886
 887           if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
 888             {
 889               gp_disp_relent = *reloc_entry;
 890               reloc_entry = &gp_disp_relent;
 891               reloc_entry->addend = l->addend;
 892             }
 893
 894           next = l->next;
 895           free (l);
 896           l = next;
 897         }
 898
 899       mips_hi16_list = NULL;
 900     }
 901   else if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
 902     {
 903       bfd_reloc_status_type ret;
 904       bfd_vma gp, relocation;
 905
 906       /* FIXME: Does this case ever occur?  */
 907
 908       ret = mips_elf_final_gp (output_bfd, symbol, TRUE, error_message, &gp);
 909       if (ret != bfd_reloc_ok)
 910         return ret;
 911
 912       relocation = gp - reloc_entry->address;
 913       relocation += symbol->section->output_section->vma;
 914       relocation += symbol->section->output_offset;
 915       relocation += reloc_entry->addend;
 916
 917       if (reloc_entry->address > input_section->_cooked_size)
 918         return bfd_reloc_outofrange;
 919
 920       gp_disp_relent = *reloc_entry;
 921       reloc_entry = &gp_disp_relent;
 922       reloc_entry->addend = relocation - 4;
 923     }
 924
 925   /* Now do the LO16 reloc in the usual way.  */
 926   return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 927                                 input_section, output_bfd, error_message);
 928 }
 929
 930 /* Do a R_MIPS_GOT16 reloc.  This is a reloc against the global offset
 931    table used for PIC code.  If the symbol is an external symbol, the
 932    instruction is modified to contain the offset of the appropriate
 933    entry in the global offset table.  If the symbol is a section
 934    symbol, the next reloc is a R_MIPS_LO16 reloc.  The two 16 bit
 935    addends are combined to form the real addend against the section
 936    symbol; the GOT16 is modified to contain the offset of an entry in
 937    the global offset table, and the LO16 is modified to offset it
 938    appropriately.  Thus an offset larger than 16 bits requires a
 939    modified value in the global offset table.
 940
 941    This implementation suffices for the assembler, but the linker does
 942    not yet know how to create global offset tables.  */
 943
 944 static bfd_reloc_status_type
 945 mips_elf_got16_reloc (abfd, reloc_entry, symbol, data, input_section,
 946                       output_bfd, error_message)
 947      bfd *abfd;
 948      arelent *reloc_entry;
 949      asymbol *symbol;
 950      PTR data;
 951      asection *input_section;
 952      bfd *output_bfd;
 953      char **error_message;
 954 {
 955   /* If we're relocating, and this is an external symbol, we don't want
 956      to change anything.  */
 957   if (output_bfd != (bfd *) NULL
 958       && (symbol->flags & BSF_SECTION_SYM) == 0
 959       && reloc_entry->addend == 0)
 960     {
 961       reloc_entry->address += input_section->output_offset;
 962       return bfd_reloc_ok;
 963     }
 964
 965   /* If we're relocating, and this is a local symbol, we can handle it
 966      just like HI16.  */
 967   if (output_bfd != (bfd *) NULL
 968       && (symbol->flags & BSF_SECTION_SYM) != 0)
 969     return mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
 970                                 input_section, output_bfd, error_message);
 971
 972   abort ();
 973 }
 974
 975 /* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
 976    dangerous relocation.  */
 977
 978 static bfd_boolean
 979 mips_elf_assign_gp (output_bfd, pgp)
 980      bfd *output_bfd;
 981      bfd_vma *pgp;
 982 {
 983   unsigned int count;
 984   asymbol **sym;
 985   unsigned int i;
 986
 987   /* If we've already figured out what GP will be, just return it.  */
 988   *pgp = _bfd_get_gp_value (output_bfd);
 989   if (*pgp)
 990     return TRUE;
 991
 992   count = bfd_get_symcount (output_bfd);
 993   sym = bfd_get_outsymbols (output_bfd);
 994
 995   /* The linker script will have created a symbol named `_gp' with the
 996      appropriate value.  */
 997   if (sym == (asymbol **) NULL)
 998     i = count;
 999   else
1000     {
1001       for (i = 0; i < count; i++, sym++)
1002         {
1003           register const char *name;
1004
1005           name = bfd_asymbol_name (*sym);
1006           if (*name == '_' && strcmp (name, "_gp") == 0)
1007             {
1008               *pgp = bfd_asymbol_value (*sym);
1009               _bfd_set_gp_value (output_bfd, *pgp);
1010               break;
1011             }
1012         }
1013     }
1014
1015   if (i >= count)
1016     {
1017       /* Only get the error once.  */
1018       *pgp = 4;
1019       _bfd_set_gp_value (output_bfd, *pgp);
1020       return FALSE;
1021     }
1022
1023   return TRUE;
1024 }
1025
1026 /* We have to figure out the gp value, so that we can adjust the
1027    symbol value correctly.  We look up the symbol _gp in the output
1028    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1029    target data.  We don't need to adjust the symbol value for an
1030    external symbol if we are producing relocateable output.  */
1031
1032 static bfd_reloc_status_type
1033 mips_elf_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1034      bfd *output_bfd;
1035      asymbol *symbol;
1036      bfd_boolean relocateable;
1037      char **error_message;
1038      bfd_vma *pgp;
1039 {
1040   if (bfd_is_und_section (symbol->section)
1041       && ! relocateable)
1042     {
1043       *pgp = 0;
1044       return bfd_reloc_undefined;
1045     }
1046
1047   *pgp = _bfd_get_gp_value (output_bfd);
1048   if (*pgp == 0
1049       && (! relocateable
1050           || (symbol->flags & BSF_SECTION_SYM) != 0))
1051     {
1052       if (relocateable)
1053         {
1054           /* Make up a value.  */
1055           *pgp = symbol->section->output_section->vma + 0x4000;
1056           _bfd_set_gp_value (output_bfd, *pgp);
1057         }
1058       else if (!mips_elf_assign_gp (output_bfd, pgp))
1059         {
1060           *error_message =
1061             (char *) _("GP relative relocation when _gp not defined");
1062           return bfd_reloc_dangerous;
1063         }
1064     }
1065
1066   return bfd_reloc_ok;
1067 }
1068
1069 /* Do a R_MIPS_GPREL16 relocation.  This is a 16 bit value which must
1070    become the offset from the gp register.  This function also handles
1071    R_MIPS_LITERAL relocations, although those can be handled more
1072    cleverly because the entries in the .lit8 and .lit4 sections can be
1073    merged.  */
1074
1075 bfd_reloc_status_type
1076 _bfd_mips_elf32_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1077                                output_bfd, error_message)
1078      bfd *abfd;
1079      arelent *reloc_entry;
1080      asymbol *symbol;
1081      PTR data;
1082      asection *input_section;
1083      bfd *output_bfd;
1084      char **error_message;
1085 {
1086   bfd_boolean relocateable;
1087   bfd_reloc_status_type ret;
1088   bfd_vma gp;
1089
1090   /* If we're relocating, and this is an external symbol with no
1091      addend, we don't want to change anything.  We will only have an
1092      addend if this is a newly created reloc, not read from an ELF
1093      file.  */
1094   if (output_bfd != (bfd *) NULL
1095       && (symbol->flags & BSF_SECTION_SYM) == 0
1096       && reloc_entry->addend == 0)
1097     {
1098       reloc_entry->address += input_section->output_offset;
1099       return bfd_reloc_ok;
1100     }
1101
1102   if (output_bfd != (bfd *) NULL)
1103     relocateable = TRUE;
1104   else
1105     {
1106       relocateable = FALSE;
1107       output_bfd = symbol->section->output_section->owner;
1108     }
1109
1110   ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1111                            &gp);
1112   if (ret != bfd_reloc_ok)
1113     return ret;
1114
1115   return _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
1116                                         input_section, relocateable,
1117                                         data, gp);
1118 }
1119
1120 /* Do a R_MIPS_GPREL32 relocation.  This is a 32 bit value which must
1121    become the offset from the gp register.  */
1122
1123 static bfd_reloc_status_type gprel32_with_gp
1124   PARAMS ((bfd *, asymbol *, arelent *, asection *, bfd_boolean, PTR,
1125            bfd_vma));
1126
1127 static bfd_reloc_status_type
1128 mips_elf_gprel32_reloc (abfd, reloc_entry, symbol, data, input_section,
1129                         output_bfd, error_message)
1130      bfd *abfd;
1131      arelent *reloc_entry;
1132      asymbol *symbol;
1133      PTR data;
1134      asection *input_section;
1135      bfd *output_bfd;
1136      char **error_message;
1137 {
1138   bfd_boolean relocateable;
1139   bfd_reloc_status_type ret;
1140   bfd_vma gp;
1141
1142   /* If we're relocating, and this is an external symbol with no
1143      addend, we don't want to change anything.  We will only have an
1144      addend if this is a newly created reloc, not read from an ELF
1145      file.  */
1146   if (output_bfd != (bfd *) NULL
1147       && (symbol->flags & BSF_SECTION_SYM) == 0
1148       && reloc_entry->addend == 0)
1149     {
1150       *error_message = (char *)
1151         _("32bits gp relative relocation occurs for an external symbol");
1152       return bfd_reloc_outofrange;
1153     }
1154
1155   if (output_bfd != (bfd *) NULL)
1156     {
1157       relocateable = TRUE;
1158       gp = _bfd_get_gp_value (output_bfd);
1159     }
1160   else
1161     {
1162       relocateable = FALSE;
1163       output_bfd = symbol->section->output_section->owner;
1164
1165       ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1166                                error_message, &gp);
1167       if (ret != bfd_reloc_ok)
1168         return ret;
1169     }
1170
1171   return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
1172                           relocateable, data, gp);
1173 }
1174
1175 static bfd_reloc_status_type
1176 gprel32_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1177                  gp)
1178      bfd *abfd;
1179      asymbol *symbol;
1180      arelent *reloc_entry;
1181      asection *input_section;
1182      bfd_boolean relocateable;
1183      PTR data;
1184      bfd_vma gp;
1185 {
1186   bfd_vma relocation;
1187   unsigned long val;
1188
1189   if (bfd_is_com_section (symbol->section))
1190     relocation = 0;
1191   else
1192     relocation = symbol->value;
1193
1194   relocation += symbol->section->output_section->vma;
1195   relocation += symbol->section->output_offset;
1196
1197   if (reloc_entry->address > input_section->_cooked_size)
1198     return bfd_reloc_outofrange;
1199
1200   if (reloc_entry->howto->src_mask == 0)
1201     {
1202       /* This case arises with the 64-bit MIPS ELF ABI.  */
1203       val = 0;
1204     }
1205   else
1206     val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1207
1208   /* Set val to the offset into the section or symbol.  */
1209   val += reloc_entry->addend;
1210
1211   /* Adjust val for the final section location and GP value.  If we
1212      are producing relocateable output, we don't want to do this for
1213      an external symbol.  */
1214   if (! relocateable
1215       || (symbol->flags & BSF_SECTION_SYM) != 0)
1216     val += relocation - gp;
1217
1218   bfd_put_32 (abfd, (bfd_vma) val, (bfd_byte *) data + reloc_entry->address);
1219
1220   if (relocateable)
1221     reloc_entry->address += input_section->output_offset;
1222
1223   return bfd_reloc_ok;
1224 }
1225
1226 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file.  These are
1227    generated when addresses are 64 bits.  The upper 32 bits are a simple
1228    sign extension.  */
1229
1230 static bfd_reloc_status_type
1231 mips32_64bit_reloc (abfd, reloc_entry, symbol, data, input_section,
1232                     output_bfd, error_message)
1233      bfd *abfd;
1234      arelent *reloc_entry;
1235      asymbol *symbol;
1236      PTR data;
1237      asection *input_section;
1238      bfd *output_bfd;
1239      char **error_message;
1240 {
1241   bfd_reloc_status_type r;
1242   arelent reloc32;
1243   unsigned long val;
1244   bfd_size_type addr;
1245
1246   r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1247                              input_section, output_bfd, error_message);
1248   if (r != bfd_reloc_continue)
1249     return r;
1250
1251   /* Do a normal 32 bit relocation on the lower 32 bits.  */
1252   reloc32 = *reloc_entry;
1253   if (bfd_big_endian (abfd))
1254     reloc32.address += 4;
1255   reloc32.howto = &elf_mips_howto_table_rel[R_MIPS_32];
1256   r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1257                               output_bfd, error_message);
1258
1259   /* Sign extend into the upper 32 bits.  */
1260   val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1261   if ((val & 0x80000000) != 0)
1262     val = 0xffffffff;
1263   else
1264     val = 0;
1265   addr = reloc_entry->address;
1266   if (bfd_little_endian (abfd))
1267     addr += 4;
1268   bfd_put_32 (abfd, (bfd_vma) val, (bfd_byte *) data + addr);
1269
1270   return r;
1271 }
1272
1273 /* Handle a mips16 jump.  */
1274
1275 static bfd_reloc_status_type
1276 mips16_jump_reloc (abfd, reloc_entry, symbol, data, input_section,
1277                    output_bfd, error_message)
1278      bfd *abfd ATTRIBUTE_UNUSED;
1279      arelent *reloc_entry;
1280      asymbol *symbol;
1281      PTR data ATTRIBUTE_UNUSED;
1282      asection *input_section;
1283      bfd *output_bfd;
1284      char **error_message ATTRIBUTE_UNUSED;
1285 {
1286   if (output_bfd != (bfd *) NULL
1287       && (symbol->flags & BSF_SECTION_SYM) == 0
1288       && reloc_entry->addend == 0)
1289     {
1290       reloc_entry->address += input_section->output_offset;
1291       return bfd_reloc_ok;
1292     }
1293
1294   /* FIXME.  */
1295   {
1296     static bfd_boolean warned;
1297
1298     if (! warned)
1299       (*_bfd_error_handler)
1300         (_("Linking mips16 objects into %s format is not supported"),
1301          bfd_get_target (input_section->output_section->owner));
1302     warned = TRUE;
1303   }
1304
1305   return bfd_reloc_undefined;
1306 }
1307
1308 /* Handle a mips16 GP relative reloc.  */
1309
1310 static bfd_reloc_status_type
1311 mips16_gprel_reloc (abfd, reloc_entry, symbol, data, input_section,
1312                     output_bfd, error_message)
1313      bfd *abfd;
1314      arelent *reloc_entry;
1315      asymbol *symbol;
1316      PTR data;
1317      asection *input_section;
1318      bfd *output_bfd;
1319      char **error_message;
1320 {
1321   bfd_boolean relocateable;
1322   bfd_reloc_status_type ret;
1323   bfd_vma gp;
1324   unsigned short extend, insn;
1325   unsigned long final;
1326
1327   /* If we're relocating, and this is an external symbol with no
1328      addend, we don't want to change anything.  We will only have an
1329      addend if this is a newly created reloc, not read from an ELF
1330      file.  */
1331   if (output_bfd != NULL
1332       && (symbol->flags & BSF_SECTION_SYM) == 0
1333       && reloc_entry->addend == 0)
1334     {
1335       reloc_entry->address += input_section->output_offset;
1336       return bfd_reloc_ok;
1337     }
1338
1339   if (output_bfd != NULL)
1340     relocateable = TRUE;
1341   else
1342     {
1343       relocateable = FALSE;
1344       output_bfd = symbol->section->output_section->owner;
1345     }
1346
1347   ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1348                            &gp);
1349   if (ret != bfd_reloc_ok)
1350     return ret;
1351
1352   if (reloc_entry->address > input_section->_cooked_size)
1353     return bfd_reloc_outofrange;
1354
1355   /* Pick up the mips16 extend instruction and the real instruction.  */
1356   extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1357   insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1358
1359   /* Stuff the current addend back as a 32 bit value, do the usual
1360      relocation, and then clean up.  */
1361   bfd_put_32 (abfd,
1362               (bfd_vma) (((extend & 0x1f) << 11)
1363                          | (extend & 0x7e0)
1364                          | (insn & 0x1f)),
1365               (bfd_byte *) data + reloc_entry->address);
1366
1367   ret = _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
1368                                        input_section, relocateable, data, gp);
1369
1370   final = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1371   bfd_put_16 (abfd,
1372               (bfd_vma) ((extend & 0xf800)
1373                          | ((final >> 11) & 0x1f)
1374                          | (final & 0x7e0)),
1375               (bfd_byte *) data + reloc_entry->address);
1376   bfd_put_16 (abfd,
1377               (bfd_vma) ((insn & 0xffe0)
1378                          | (final & 0x1f)),
1379               (bfd_byte *) data + reloc_entry->address + 2);
1380
1381   return ret;
1382 }
1383
1384 /* A mapping from BFD reloc types to MIPS ELF reloc types.  */
1385
1386 struct elf_reloc_map {
1387   bfd_reloc_code_real_type bfd_val;
1388   enum elf_mips_reloc_type elf_val;
1389 };
1390
1391 static const struct elf_reloc_map mips_reloc_map[] =
1392 {
1393   { BFD_RELOC_NONE, R_MIPS_NONE },
1394   { BFD_RELOC_16, R_MIPS_16 },
1395   { BFD_RELOC_32, R_MIPS_32 },
1396   /* There is no BFD reloc for R_MIPS_REL32.  */
1397   { BFD_RELOC_64, R_MIPS_64 },
1398   { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1399   { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1400   { BFD_RELOC_LO16, R_MIPS_LO16 },
1401   { BFD_RELOC_GPREL16, R_MIPS_GPREL16 },
1402   { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1403   { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1404   { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1405   { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1406   { BFD_RELOC_GPREL32, R_MIPS_GPREL32 },
1407   { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1408   { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1409   { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
1410   { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1411   { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1412   { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1413   { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1414   { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
1415 };
1416
1417 /* Given a BFD reloc type, return a howto structure.  */
1418
1419 static reloc_howto_type *
1420 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1421      bfd *abfd;
1422      bfd_reloc_code_real_type code;
1423 {
1424   unsigned int i;
1425   reloc_howto_type *howto_table = elf_mips_howto_table_rel;
1426
1427   for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map);
1428        i++)
1429     {
1430       if (mips_reloc_map[i].bfd_val == code)
1431         return &howto_table[(int) mips_reloc_map[i].elf_val];
1432     }
1433
1434   switch (code)
1435     {
1436     default:
1437       bfd_set_error (bfd_error_bad_value);
1438       return NULL;
1439
1440     case BFD_RELOC_CTOR:
1441       /* We need to handle BFD_RELOC_CTOR specially.
1442          Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1443          size of addresses on this architecture.  */
1444       if (bfd_arch_bits_per_address (abfd) == 32)
1445         return &howto_table[(int) R_MIPS_32];
1446       else
1447         return &elf_mips_ctor64_howto;
1448
1449     case BFD_RELOC_MIPS16_JMP:
1450       return &elf_mips16_jump_howto;
1451     case BFD_RELOC_MIPS16_GPREL:
1452       return &elf_mips16_gprel_howto;
1453     case BFD_RELOC_VTABLE_INHERIT:
1454       return &elf_mips_gnu_vtinherit_howto;
1455     case BFD_RELOC_VTABLE_ENTRY:
1456       return &elf_mips_gnu_vtentry_howto;
1457     case BFD_RELOC_PCREL_HI16_S:
1458       return &elf_mips_gnu_rel_hi16;
1459     case BFD_RELOC_PCREL_LO16:
1460       return &elf_mips_gnu_rel_lo16;
1461     case BFD_RELOC_16_PCREL_S2:
1462       return &elf_mips_gnu_rel16_s2;
1463     case BFD_RELOC_64_PCREL:
1464       return &elf_mips_gnu_pcrel64;
1465     case BFD_RELOC_32_PCREL:
1466       return &elf_mips_gnu_pcrel32;
1467     }
1468 }
1469
1470 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure.  */
1471
1472 static reloc_howto_type *
1473 mips_elf32_rtype_to_howto (r_type, rela_p)
1474      unsigned int r_type;
1475      bfd_boolean rela_p ATTRIBUTE_UNUSED;
1476 {
1477   switch (r_type)
1478     {
1479     case R_MIPS16_26:
1480       return &elf_mips16_jump_howto;
1481     case R_MIPS16_GPREL:
1482       return &elf_mips16_gprel_howto;
1483     case R_MIPS_GNU_VTINHERIT:
1484       return &elf_mips_gnu_vtinherit_howto;
1485     case R_MIPS_GNU_VTENTRY:
1486       return &elf_mips_gnu_vtentry_howto;
1487     case R_MIPS_GNU_REL_HI16:
1488       return &elf_mips_gnu_rel_hi16;
1489     case R_MIPS_GNU_REL_LO16:
1490       return &elf_mips_gnu_rel_lo16;
1491     case R_MIPS_GNU_REL16_S2:
1492       return &elf_mips_gnu_rel16_s2;
1493     case R_MIPS_PC64:
1494       return &elf_mips_gnu_pcrel64;
1495     case R_MIPS_PC32:
1496       return &elf_mips_gnu_pcrel32;
1497     default:
1498       BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
1499       return &elf_mips_howto_table_rel[r_type];
1500     }
1501 }
1502
1503 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure.  */
1504
1505 static void
1506 mips_info_to_howto_rel (abfd, cache_ptr, dst)
1507      bfd *abfd;
1508      arelent *cache_ptr;
1509      Elf_Internal_Rela *dst;
1510 {
1511   unsigned int r_type;
1512
1513   r_type = ELF32_R_TYPE (dst->r_info);
1514   cache_ptr->howto = mips_elf32_rtype_to_howto (r_type, FALSE);
1515
1516   /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1517      value for the object file.  We get the addend now, rather than
1518      when we do the relocation, because the symbol manipulations done
1519      by the linker may cause us to lose track of the input BFD.  */
1520   if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
1521       && (r_type == (unsigned int) R_MIPS_GPREL16
1522           || r_type == (unsigned int) R_MIPS_LITERAL))
1523     cache_ptr->addend = elf_gp (abfd);
1524 }
1525
1526 /* Given a MIPS Elf_Internal_Rela, fill in an arelent structure.  */
1527
1528 static void
1529 mips_info_to_howto_rela (abfd, cache_ptr, dst)
1530      bfd *abfd;
1531      arelent *cache_ptr;
1532      Elf_Internal_Rela *dst;
1533 {
1534   mips_info_to_howto_rel (abfd, cache_ptr, dst);
1535
1536   /* If we ever need to do any extra processing with dst->r_addend
1537      (the field omitted in an Elf_Internal_Rel) we can do it here.  */
1538 }
1539 \f
1540 /* Determine whether a symbol is global for the purposes of splitting
1541    the symbol table into global symbols and local symbols.  At least
1542    on Irix 5, this split must be between section symbols and all other
1543    symbols.  On most ELF targets the split is between static symbols
1544    and externally visible symbols.  */
1545
1546 static bfd_boolean
1547 mips_elf_sym_is_global (abfd, sym)
1548      bfd *abfd ATTRIBUTE_UNUSED;
1549      asymbol *sym;
1550 {
1551   if (SGI_COMPAT (abfd))
1552     return (sym->flags & BSF_SECTION_SYM) == 0;
1553   else
1554     return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1555             || bfd_is_und_section (bfd_get_section (sym))
1556             || bfd_is_com_section (bfd_get_section (sym)));
1557 }
1558 \f
1559 /* Set the right machine number for a MIPS ELF file.  */
1560
1561 static bfd_boolean
1562 mips_elf32_object_p (abfd)
1563      bfd *abfd;
1564 {
1565   unsigned long mach;
1566
1567   /* Irix 5 and 6 are broken.  Object file symbol tables are not always
1568      sorted correctly such that local symbols precede global symbols,
1569      and the sh_info field in the symbol table is not always right.  */
1570   if (SGI_COMPAT (abfd))
1571     elf_bad_symtab (abfd) = TRUE;
1572
1573   if (ABI_N32_P (abfd))
1574     return FALSE;
1575
1576   mach = _bfd_elf_mips_mach (elf_elfheader (abfd)->e_flags);
1577   bfd_default_set_arch_mach (abfd, bfd_arch_mips, mach);
1578
1579   return TRUE;
1580 }
1581 \f
1582 /* MIPS ELF local labels start with '$', not 'L'.  */
1583
1584 static bfd_boolean
1585 mips_elf_is_local_label_name (abfd, name)
1586      bfd *abfd;
1587      const char *name;
1588 {
1589   if (name[0] == '$')
1590     return TRUE;
1591
1592   /* On Irix 6, the labels go back to starting with '.', so we accept
1593      the generic ELF local label syntax as well.  */
1594   return _bfd_elf_is_local_label_name (abfd, name);
1595 }
1596 \f
1597 /* Support for core dump NOTE sections.  */
1598 static bfd_boolean
1599 elf32_mips_grok_prstatus (abfd, note)
1600      bfd *abfd;
1601      Elf_Internal_Note *note;
1602 {
1603   int offset;
1604   unsigned int raw_size;
1605
1606   switch (note->descsz)
1607     {
1608       default:
1609         return FALSE;
1610
1611       case 256:         /* Linux/MIPS */
1612         /* pr_cursig */
1613         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1614
1615         /* pr_pid */
1616         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1617
1618         /* pr_reg */
1619         offset = 72;
1620         raw_size = 180;
1621
1622         break;
1623     }
1624
1625   /* Make a ".reg/999" section.  */
1626   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1627                                           raw_size, note->descpos + offset);
1628 }
1629
1630 static bfd_boolean
1631 elf32_mips_grok_psinfo (abfd, note)
1632      bfd *abfd;
1633      Elf_Internal_Note *note;
1634 {
1635   switch (note->descsz)
1636     {
1637       default:
1638         return FALSE;
1639
1640       case 128:         /* Linux/MIPS elf_prpsinfo */
1641         elf_tdata (abfd)->core_program
1642          = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
1643         elf_tdata (abfd)->core_command
1644          = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
1645     }
1646
1647   /* Note that for some reason, a spurious space is tacked
1648      onto the end of the args in some (at least one anyway)
1649      implementations, so strip it off if it exists.  */
1650
1651   {
1652     char *command = elf_tdata (abfd)->core_command;
1653     int n = strlen (command);
1654
1655     if (0 < n && command[n - 1] == ' ')
1656       command[n - 1] = '\0';
1657   }
1658
1659   return TRUE;
1660 }
1661 \f
1662 /* Depending on the target vector we generate some version of Irix
1663    executables or "normal" MIPS ELF ABI executables.  */
1664 static irix_compat_t
1665 elf32_mips_irix_compat (abfd)
1666      bfd *abfd;
1667 {
1668   if ((abfd->xvec == &bfd_elf32_bigmips_vec)
1669       || (abfd->xvec == &bfd_elf32_littlemips_vec))
1670     return ict_irix5;
1671   else
1672     return ict_none;
1673 }
1674 \f
1675 /* Given a data section and an in-memory embedded reloc section, store
1676    relocation information into the embedded reloc section which can be
1677    used at runtime to relocate the data section.  This is called by the
1678    linker when the --embedded-relocs switch is used.  This is called
1679    after the add_symbols entry point has been called for all the
1680    objects, and before the final_link entry point is called.  */
1681
1682 bfd_boolean
1683 bfd_mips_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
1684      bfd *abfd;
1685      struct bfd_link_info *info;
1686      asection *datasec;
1687      asection *relsec;
1688      char **errmsg;
1689 {
1690   Elf_Internal_Shdr *symtab_hdr;
1691   Elf_Internal_Sym *isymbuf = NULL;
1692   Elf_Internal_Rela *internal_relocs = NULL;
1693   Elf_Internal_Rela *irel, *irelend;
1694   bfd_byte *p;
1695
1696   BFD_ASSERT (! info->relocateable);
1697
1698   *errmsg = NULL;
1699
1700   if (datasec->reloc_count == 0)
1701     return TRUE;
1702
1703   /* Read this BFD's symbols if we haven't done so already, or get the cached
1704      copy if it exists.  */
1705   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1706   if (symtab_hdr->sh_info != 0)
1707     {
1708       isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1709       if (isymbuf == NULL)
1710         isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1711                                         symtab_hdr->sh_info, 0,
1712                                         NULL, NULL, NULL);
1713       if (isymbuf == NULL)
1714         goto error_return;
1715     }
1716
1717   /* Get a copy of the native relocations.  */
1718   internal_relocs = (_bfd_elf32_link_read_relocs
1719                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1720                       info->keep_memory));
1721   if (internal_relocs == NULL)
1722     goto error_return;
1723
1724   relsec->contents = (bfd_byte *) bfd_alloc (abfd, datasec->reloc_count * 12);
1725   if (relsec->contents == NULL)
1726     goto error_return;
1727
1728   p = relsec->contents;
1729
1730   irelend = internal_relocs + datasec->reloc_count;
1731
1732   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
1733     {
1734       asection *targetsec;
1735
1736       /* We are going to write a four byte longword into the runtime
1737          reloc section.  The longword will be the address in the data
1738          section which must be relocated.  It is followed by the name
1739          of the target section NUL-padded or truncated to 8
1740          characters.  */
1741
1742       /* We can only relocate absolute longword relocs at run time.  */
1743       if ((ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_32) &&
1744           (ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_64))
1745         {
1746           *errmsg = _("unsupported reloc type");
1747           bfd_set_error (bfd_error_bad_value);
1748           goto error_return;
1749         }
1750       /* Get the target section referred to by the reloc.  */
1751       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1752         {
1753           Elf_Internal_Sym *isym;
1754
1755           /* A local symbol.  */
1756           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1757           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1758         }
1759       else
1760         {
1761           unsigned long indx;
1762           struct elf_link_hash_entry *h;
1763
1764           /* An external symbol.  */
1765           indx = ELF32_R_SYM (irel->r_info);
1766           h = elf_sym_hashes (abfd)[indx];
1767           targetsec = NULL;
1768           /*
1769              For some reason, in certain programs, the symbol will
1770              not be in the hash table.  It seems to happen when you
1771              declare a static table of pointers to const external structures.
1772              In this case, the relocs are relative to data, not
1773              text, so just treating it like an undefined link
1774              should be sufficient.  */
1775           BFD_ASSERT(h != NULL);
1776           if (h->root.type == bfd_link_hash_defined
1777               || h->root.type == bfd_link_hash_defweak)
1778             targetsec = h->root.u.def.section;
1779         }
1780
1781
1782       /*
1783          Set the low bit of the relocation offset if it's a MIPS64 reloc.
1784          Relocations will always be on (at least) 32-bit boundaries.  */
1785
1786       bfd_put_32 (abfd, ((irel->r_offset + datasec->output_offset) +
1787                   ((ELF32_R_TYPE (irel->r_info) == (int) R_MIPS_64) ? 1 : 0)),
1788                   p);
1789       memset (p + 4, 0, 8);
1790       if (targetsec != NULL)
1791         strncpy (p + 4, targetsec->output_section->name, 8);
1792     }
1793
1794   if (internal_relocs != NULL
1795       && elf_section_data (datasec)->relocs != internal_relocs)
1796     free (internal_relocs);
1797   if (isymbuf != NULL
1798       && symtab_hdr->contents != (unsigned char *) isymbuf)
1799     free (isymbuf);
1800   return TRUE;
1801
1802  error_return:
1803   if (internal_relocs != NULL
1804       && elf_section_data (datasec)->relocs != internal_relocs)
1805     free (internal_relocs);
1806   if (isymbuf != NULL
1807       && symtab_hdr->contents != (unsigned char *) isymbuf)
1808     free (isymbuf);
1809   return FALSE;
1810 }
1811 \f
1812 /* ECOFF swapping routines.  These are used when dealing with the
1813    .mdebug section, which is in the ECOFF debugging format.  */
1814 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
1815   /* Symbol table magic number.  */
1816   magicSym,
1817   /* Alignment of debugging information.  E.g., 4.  */
1818   4,
1819   /* Sizes of external symbolic information.  */
1820   sizeof (struct hdr_ext),
1821   sizeof (struct dnr_ext),
1822   sizeof (struct pdr_ext),
1823   sizeof (struct sym_ext),
1824   sizeof (struct opt_ext),
1825   sizeof (struct fdr_ext),
1826   sizeof (struct rfd_ext),
1827   sizeof (struct ext_ext),
1828   /* Functions to swap in external symbolic data.  */
1829   ecoff_swap_hdr_in,
1830   ecoff_swap_dnr_in,
1831   ecoff_swap_pdr_in,
1832   ecoff_swap_sym_in,
1833   ecoff_swap_opt_in,
1834   ecoff_swap_fdr_in,
1835   ecoff_swap_rfd_in,
1836   ecoff_swap_ext_in,
1837   _bfd_ecoff_swap_tir_in,
1838   _bfd_ecoff_swap_rndx_in,
1839   /* Functions to swap out external symbolic data.  */
1840   ecoff_swap_hdr_out,
1841   ecoff_swap_dnr_out,
1842   ecoff_swap_pdr_out,
1843   ecoff_swap_sym_out,
1844   ecoff_swap_opt_out,
1845   ecoff_swap_fdr_out,
1846   ecoff_swap_rfd_out,
1847   ecoff_swap_ext_out,
1848   _bfd_ecoff_swap_tir_out,
1849   _bfd_ecoff_swap_rndx_out,
1850   /* Function to read in symbolic data.  */
1851   _bfd_mips_elf_read_ecoff_info
1852 };
1853 \f
1854 #define ELF_ARCH                        bfd_arch_mips
1855 #define ELF_MACHINE_CODE                EM_MIPS
1856
1857 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
1858    a value of 0x1000, and we are compatible.  */
1859 #define ELF_MAXPAGESIZE                 0x1000
1860
1861 #define elf_backend_collect             TRUE
1862 #define elf_backend_type_change_ok      TRUE
1863 #define elf_backend_can_gc_sections     TRUE
1864 #define elf_info_to_howto               mips_info_to_howto_rela
1865 #define elf_info_to_howto_rel           mips_info_to_howto_rel
1866 #define elf_backend_sym_is_global       mips_elf_sym_is_global
1867 #define elf_backend_object_p            mips_elf32_object_p
1868 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
1869 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
1870 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
1871 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
1872 #define elf_backend_section_from_bfd_section \
1873                                         _bfd_mips_elf_section_from_bfd_section
1874 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
1875 #define elf_backend_link_output_symbol_hook \
1876                                         _bfd_mips_elf_link_output_symbol_hook
1877 #define elf_backend_create_dynamic_sections \
1878                                         _bfd_mips_elf_create_dynamic_sections
1879 #define elf_backend_check_relocs        _bfd_mips_elf_check_relocs
1880 #define elf_backend_adjust_dynamic_symbol \
1881                                         _bfd_mips_elf_adjust_dynamic_symbol
1882 #define elf_backend_always_size_sections \
1883                                         _bfd_mips_elf_always_size_sections
1884 #define elf_backend_size_dynamic_sections \
1885                                         _bfd_mips_elf_size_dynamic_sections
1886 #define elf_backend_relocate_section    _bfd_mips_elf_relocate_section
1887 #define elf_backend_finish_dynamic_symbol \
1888                                         _bfd_mips_elf_finish_dynamic_symbol
1889 #define elf_backend_finish_dynamic_sections \
1890                                         _bfd_mips_elf_finish_dynamic_sections
1891 #define elf_backend_final_write_processing \
1892                                         _bfd_mips_elf_final_write_processing
1893 #define elf_backend_additional_program_headers \
1894                                         _bfd_mips_elf_additional_program_headers
1895 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
1896 #define elf_backend_gc_mark_hook        _bfd_mips_elf_gc_mark_hook
1897 #define elf_backend_gc_sweep_hook       _bfd_mips_elf_gc_sweep_hook
1898 #define elf_backend_copy_indirect_symbol \
1899                                         _bfd_mips_elf_copy_indirect_symbol
1900 #define elf_backend_hide_symbol         _bfd_mips_elf_hide_symbol
1901 #define elf_backend_grok_prstatus       elf32_mips_grok_prstatus
1902 #define elf_backend_grok_psinfo         elf32_mips_grok_psinfo
1903 #define elf_backend_ecoff_debug_swap    &mips_elf32_ecoff_debug_swap
1904
1905 #define elf_backend_got_header_size     (4 * MIPS_RESERVED_GOTNO)
1906 #define elf_backend_plt_header_size     0
1907 #define elf_backend_may_use_rel_p       1
1908 #define elf_backend_may_use_rela_p      0
1909 #define elf_backend_default_use_rela_p  0
1910 #define elf_backend_sign_extend_vma     TRUE
1911
1912 #define elf_backend_discard_info        _bfd_mips_elf_discard_info
1913 #define elf_backend_ignore_discarded_relocs \
1914                                         _bfd_mips_elf_ignore_discarded_relocs
1915 #define elf_backend_mips_irix_compat    elf32_mips_irix_compat
1916 #define elf_backend_mips_rtype_to_howto mips_elf32_rtype_to_howto
1917 #define bfd_elf32_bfd_is_local_label_name \
1918                                         mips_elf_is_local_label_name
1919 #define bfd_elf32_find_nearest_line     _bfd_mips_elf_find_nearest_line
1920 #define bfd_elf32_new_section_hook      _bfd_mips_elf_new_section_hook
1921 #define bfd_elf32_set_section_contents  _bfd_mips_elf_set_section_contents
1922 #define bfd_elf32_bfd_get_relocated_section_contents \
1923                                 _bfd_elf_mips_get_relocated_section_contents
1924 #define bfd_elf32_bfd_link_hash_table_create \
1925                                         _bfd_mips_elf_link_hash_table_create
1926 #define bfd_elf32_bfd_final_link        _bfd_mips_elf_final_link
1927 #define bfd_elf32_bfd_merge_private_bfd_data \
1928                                         _bfd_mips_elf_merge_private_bfd_data
1929 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
1930 #define bfd_elf32_bfd_print_private_bfd_data \
1931                                         _bfd_mips_elf_print_private_bfd_data
1932
1933 /* Support for SGI-ish mips targets.  */
1934 #define TARGET_LITTLE_SYM               bfd_elf32_littlemips_vec
1935 #define TARGET_LITTLE_NAME              "elf32-littlemips"
1936 #define TARGET_BIG_SYM                  bfd_elf32_bigmips_vec
1937 #define TARGET_BIG_NAME                 "elf32-bigmips"
1938
1939 #include "elf32-target.h"
1940
1941 /* Support for traditional mips targets.  */
1942 #define INCLUDED_TARGET_FILE            /* More a type of flag.  */
1943
1944 #undef TARGET_LITTLE_SYM
1945 #undef TARGET_LITTLE_NAME
1946 #undef TARGET_BIG_SYM
1947 #undef TARGET_BIG_NAME
1948
1949 #define TARGET_LITTLE_SYM               bfd_elf32_tradlittlemips_vec
1950 #define TARGET_LITTLE_NAME              "elf32-tradlittlemips"
1951 #define TARGET_BIG_SYM                  bfd_elf32_tradbigmips_vec
1952 #define TARGET_BIG_NAME                 "elf32-tradbigmips"
1953
1954 /* Include the target file again for this target.  */
1955 #include "elf32-target.h"