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   val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1201
1202   /* Set val to the offset into the section or symbol.  */
1203   val += reloc_entry->addend;
1204
1205   /* Adjust val for the final section location and GP value.  If we
1206      are producing relocateable output, we don't want to do this for
1207      an external symbol.  */
1208   if (! relocateable
1209       || (symbol->flags & BSF_SECTION_SYM) != 0)
1210     val += relocation - gp;
1211
1212   bfd_put_32 (abfd, (bfd_vma) val, (bfd_byte *) data + reloc_entry->address);
1213
1214   if (relocateable)
1215     reloc_entry->address += input_section->output_offset;
1216
1217   return bfd_reloc_ok;
1218 }
1219
1220 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file.  These are
1221    generated when addresses are 64 bits.  The upper 32 bits are a simple
1222    sign extension.  */
1223
1224 static bfd_reloc_status_type
1225 mips32_64bit_reloc (abfd, reloc_entry, symbol, data, input_section,
1226                     output_bfd, error_message)
1227      bfd *abfd;
1228      arelent *reloc_entry;
1229      asymbol *symbol;
1230      PTR data;
1231      asection *input_section;
1232      bfd *output_bfd;
1233      char **error_message;
1234 {
1235   bfd_reloc_status_type r;
1236   arelent reloc32;
1237   unsigned long val;
1238   bfd_size_type addr;
1239
1240   r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1241                              input_section, output_bfd, error_message);
1242   if (r != bfd_reloc_continue)
1243     return r;
1244
1245   /* Do a normal 32 bit relocation on the lower 32 bits.  */
1246   reloc32 = *reloc_entry;
1247   if (bfd_big_endian (abfd))
1248     reloc32.address += 4;
1249   reloc32.howto = &elf_mips_howto_table_rel[R_MIPS_32];
1250   r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1251                               output_bfd, error_message);
1252
1253   /* Sign extend into the upper 32 bits.  */
1254   val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1255   if ((val & 0x80000000) != 0)
1256     val = 0xffffffff;
1257   else
1258     val = 0;
1259   addr = reloc_entry->address;
1260   if (bfd_little_endian (abfd))
1261     addr += 4;
1262   bfd_put_32 (abfd, (bfd_vma) val, (bfd_byte *) data + addr);
1263
1264   return r;
1265 }
1266
1267 /* Handle a mips16 jump.  */
1268
1269 static bfd_reloc_status_type
1270 mips16_jump_reloc (abfd, reloc_entry, symbol, data, input_section,
1271                    output_bfd, error_message)
1272      bfd *abfd ATTRIBUTE_UNUSED;
1273      arelent *reloc_entry;
1274      asymbol *symbol;
1275      PTR data ATTRIBUTE_UNUSED;
1276      asection *input_section;
1277      bfd *output_bfd;
1278      char **error_message ATTRIBUTE_UNUSED;
1279 {
1280   if (output_bfd != (bfd *) NULL
1281       && (symbol->flags & BSF_SECTION_SYM) == 0
1282       && reloc_entry->addend == 0)
1283     {
1284       reloc_entry->address += input_section->output_offset;
1285       return bfd_reloc_ok;
1286     }
1287
1288   /* FIXME.  */
1289   {
1290     static bfd_boolean warned;
1291
1292     if (! warned)
1293       (*_bfd_error_handler)
1294         (_("Linking mips16 objects into %s format is not supported"),
1295          bfd_get_target (input_section->output_section->owner));
1296     warned = TRUE;
1297   }
1298
1299   return bfd_reloc_undefined;
1300 }
1301
1302 /* Handle a mips16 GP relative reloc.  */
1303
1304 static bfd_reloc_status_type
1305 mips16_gprel_reloc (abfd, reloc_entry, symbol, data, input_section,
1306                     output_bfd, error_message)
1307      bfd *abfd;
1308      arelent *reloc_entry;
1309      asymbol *symbol;
1310      PTR data;
1311      asection *input_section;
1312      bfd *output_bfd;
1313      char **error_message;
1314 {
1315   bfd_boolean relocateable;
1316   bfd_reloc_status_type ret;
1317   bfd_vma gp;
1318   unsigned short extend, insn;
1319   unsigned long final;
1320
1321   /* If we're relocating, and this is an external symbol with no
1322      addend, we don't want to change anything.  We will only have an
1323      addend if this is a newly created reloc, not read from an ELF
1324      file.  */
1325   if (output_bfd != NULL
1326       && (symbol->flags & BSF_SECTION_SYM) == 0
1327       && reloc_entry->addend == 0)
1328     {
1329       reloc_entry->address += input_section->output_offset;
1330       return bfd_reloc_ok;
1331     }
1332
1333   if (output_bfd != NULL)
1334     relocateable = TRUE;
1335   else
1336     {
1337       relocateable = FALSE;
1338       output_bfd = symbol->section->output_section->owner;
1339     }
1340
1341   ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1342                            &gp);
1343   if (ret != bfd_reloc_ok)
1344     return ret;
1345
1346   if (reloc_entry->address > input_section->_cooked_size)
1347     return bfd_reloc_outofrange;
1348
1349   /* Pick up the mips16 extend instruction and the real instruction.  */
1350   extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1351   insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1352
1353   /* Stuff the current addend back as a 32 bit value, do the usual
1354      relocation, and then clean up.  */
1355   bfd_put_32 (abfd,
1356               (bfd_vma) (((extend & 0x1f) << 11)
1357                          | (extend & 0x7e0)
1358                          | (insn & 0x1f)),
1359               (bfd_byte *) data + reloc_entry->address);
1360
1361   ret = _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
1362                                        input_section, relocateable, data, gp);
1363
1364   final = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1365   bfd_put_16 (abfd,
1366               (bfd_vma) ((extend & 0xf800)
1367                          | ((final >> 11) & 0x1f)
1368                          | (final & 0x7e0)),
1369               (bfd_byte *) data + reloc_entry->address);
1370   bfd_put_16 (abfd,
1371               (bfd_vma) ((insn & 0xffe0)
1372                          | (final & 0x1f)),
1373               (bfd_byte *) data + reloc_entry->address + 2);
1374
1375   return ret;
1376 }
1377
1378 /* A mapping from BFD reloc types to MIPS ELF reloc types.  */
1379
1380 struct elf_reloc_map {
1381   bfd_reloc_code_real_type bfd_val;
1382   enum elf_mips_reloc_type elf_val;
1383 };
1384
1385 static const struct elf_reloc_map mips_reloc_map[] =
1386 {
1387   { BFD_RELOC_NONE, R_MIPS_NONE },
1388   { BFD_RELOC_16, R_MIPS_16 },
1389   { BFD_RELOC_32, R_MIPS_32 },
1390   /* There is no BFD reloc for R_MIPS_REL32.  */
1391   { BFD_RELOC_64, R_MIPS_64 },
1392   { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1393   { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1394   { BFD_RELOC_LO16, R_MIPS_LO16 },
1395   { BFD_RELOC_GPREL16, R_MIPS_GPREL16 },
1396   { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1397   { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1398   { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1399   { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1400   { BFD_RELOC_GPREL32, R_MIPS_GPREL32 },
1401   { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1402   { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1403   { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
1404   { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1405   { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1406   { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1407   { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1408   { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
1409 };
1410
1411 /* Given a BFD reloc type, return a howto structure.  */
1412
1413 static reloc_howto_type *
1414 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1415      bfd *abfd;
1416      bfd_reloc_code_real_type code;
1417 {
1418   unsigned int i;
1419   reloc_howto_type *howto_table = elf_mips_howto_table_rel;
1420
1421   for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map);
1422        i++)
1423     {
1424       if (mips_reloc_map[i].bfd_val == code)
1425         return &howto_table[(int) mips_reloc_map[i].elf_val];
1426     }
1427
1428   switch (code)
1429     {
1430     default:
1431       bfd_set_error (bfd_error_bad_value);
1432       return NULL;
1433
1434     case BFD_RELOC_CTOR:
1435       /* We need to handle BFD_RELOC_CTOR specially.
1436          Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1437          size of addresses of the ABI.  */
1438       if ((elf_elfheader (abfd)->e_flags & (E_MIPS_ABI_O64
1439                                             | E_MIPS_ABI_EABI64)) != 0)
1440         return &elf_mips_ctor64_howto;
1441       else
1442         return &howto_table[(int) R_MIPS_32];
1443
1444     case BFD_RELOC_MIPS16_JMP:
1445       return &elf_mips16_jump_howto;
1446     case BFD_RELOC_MIPS16_GPREL:
1447       return &elf_mips16_gprel_howto;
1448     case BFD_RELOC_VTABLE_INHERIT:
1449       return &elf_mips_gnu_vtinherit_howto;
1450     case BFD_RELOC_VTABLE_ENTRY:
1451       return &elf_mips_gnu_vtentry_howto;
1452     case BFD_RELOC_PCREL_HI16_S:
1453       return &elf_mips_gnu_rel_hi16;
1454     case BFD_RELOC_PCREL_LO16:
1455       return &elf_mips_gnu_rel_lo16;
1456     case BFD_RELOC_16_PCREL_S2:
1457       return &elf_mips_gnu_rel16_s2;
1458     case BFD_RELOC_64_PCREL:
1459       return &elf_mips_gnu_pcrel64;
1460     case BFD_RELOC_32_PCREL:
1461       return &elf_mips_gnu_pcrel32;
1462     }
1463 }
1464
1465 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure.  */
1466
1467 static reloc_howto_type *
1468 mips_elf32_rtype_to_howto (r_type, rela_p)
1469      unsigned int r_type;
1470      bfd_boolean rela_p ATTRIBUTE_UNUSED;
1471 {
1472   switch (r_type)
1473     {
1474     case R_MIPS16_26:
1475       return &elf_mips16_jump_howto;
1476     case R_MIPS16_GPREL:
1477       return &elf_mips16_gprel_howto;
1478     case R_MIPS_GNU_VTINHERIT:
1479       return &elf_mips_gnu_vtinherit_howto;
1480     case R_MIPS_GNU_VTENTRY:
1481       return &elf_mips_gnu_vtentry_howto;
1482     case R_MIPS_GNU_REL_HI16:
1483       return &elf_mips_gnu_rel_hi16;
1484     case R_MIPS_GNU_REL_LO16:
1485       return &elf_mips_gnu_rel_lo16;
1486     case R_MIPS_GNU_REL16_S2:
1487       return &elf_mips_gnu_rel16_s2;
1488     case R_MIPS_PC64:
1489       return &elf_mips_gnu_pcrel64;
1490     case R_MIPS_PC32:
1491       return &elf_mips_gnu_pcrel32;
1492     default:
1493       BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
1494       return &elf_mips_howto_table_rel[r_type];
1495     }
1496 }
1497
1498 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure.  */
1499
1500 static void
1501 mips_info_to_howto_rel (abfd, cache_ptr, dst)
1502      bfd *abfd;
1503      arelent *cache_ptr;
1504      Elf_Internal_Rela *dst;
1505 {
1506   unsigned int r_type;
1507
1508   r_type = ELF32_R_TYPE (dst->r_info);
1509   cache_ptr->howto = mips_elf32_rtype_to_howto (r_type, FALSE);
1510
1511   /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1512      value for the object file.  We get the addend now, rather than
1513      when we do the relocation, because the symbol manipulations done
1514      by the linker may cause us to lose track of the input BFD.  */
1515   if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
1516       && (r_type == (unsigned int) R_MIPS_GPREL16
1517           || r_type == (unsigned int) R_MIPS_LITERAL))
1518     cache_ptr->addend = elf_gp (abfd);
1519 }
1520
1521 /* Given a MIPS Elf_Internal_Rela, fill in an arelent structure.  */
1522
1523 static void
1524 mips_info_to_howto_rela (abfd, cache_ptr, dst)
1525      bfd *abfd;
1526      arelent *cache_ptr;
1527      Elf_Internal_Rela *dst;
1528 {
1529   mips_info_to_howto_rel (abfd, cache_ptr, dst);
1530
1531   /* If we ever need to do any extra processing with dst->r_addend
1532      (the field omitted in an Elf_Internal_Rel) we can do it here.  */
1533 }
1534 \f
1535 /* Determine whether a symbol is global for the purposes of splitting
1536    the symbol table into global symbols and local symbols.  At least
1537    on Irix 5, this split must be between section symbols and all other
1538    symbols.  On most ELF targets the split is between static symbols
1539    and externally visible symbols.  */
1540
1541 static bfd_boolean
1542 mips_elf_sym_is_global (abfd, sym)
1543      bfd *abfd ATTRIBUTE_UNUSED;
1544      asymbol *sym;
1545 {
1546   if (SGI_COMPAT (abfd))
1547     return (sym->flags & BSF_SECTION_SYM) == 0;
1548   else
1549     return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1550             || bfd_is_und_section (bfd_get_section (sym))
1551             || bfd_is_com_section (bfd_get_section (sym)));
1552 }
1553 \f
1554 /* Set the right machine number for a MIPS ELF file.  */
1555
1556 static bfd_boolean
1557 mips_elf32_object_p (abfd)
1558      bfd *abfd;
1559 {
1560   unsigned long mach;
1561
1562   /* Irix 5 and 6 are broken.  Object file symbol tables are not always
1563      sorted correctly such that local symbols precede global symbols,
1564      and the sh_info field in the symbol table is not always right.  */
1565   if (SGI_COMPAT (abfd))
1566     elf_bad_symtab (abfd) = TRUE;
1567
1568   if (ABI_N32_P (abfd))
1569     return FALSE;
1570
1571   mach = _bfd_elf_mips_mach (elf_elfheader (abfd)->e_flags);
1572   bfd_default_set_arch_mach (abfd, bfd_arch_mips, mach);
1573
1574   return TRUE;
1575 }
1576 \f
1577 /* MIPS ELF local labels start with '$', not 'L'.  */
1578
1579 static bfd_boolean
1580 mips_elf_is_local_label_name (abfd, name)
1581      bfd *abfd;
1582      const char *name;
1583 {
1584   if (name[0] == '$')
1585     return TRUE;
1586
1587   /* On Irix 6, the labels go back to starting with '.', so we accept
1588      the generic ELF local label syntax as well.  */
1589   return _bfd_elf_is_local_label_name (abfd, name);
1590 }
1591 \f
1592 /* Support for core dump NOTE sections.  */
1593 static bfd_boolean
1594 elf32_mips_grok_prstatus (abfd, note)
1595      bfd *abfd;
1596      Elf_Internal_Note *note;
1597 {
1598   int offset;
1599   unsigned int raw_size;
1600
1601   switch (note->descsz)
1602     {
1603       default:
1604         return FALSE;
1605
1606       case 256:         /* Linux/MIPS */
1607         /* pr_cursig */
1608         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1609
1610         /* pr_pid */
1611         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1612
1613         /* pr_reg */
1614         offset = 72;
1615         raw_size = 180;
1616
1617         break;
1618     }
1619
1620   /* Make a ".reg/999" section.  */
1621   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1622                                           raw_size, note->descpos + offset);
1623 }
1624
1625 static bfd_boolean
1626 elf32_mips_grok_psinfo (abfd, note)
1627      bfd *abfd;
1628      Elf_Internal_Note *note;
1629 {
1630   switch (note->descsz)
1631     {
1632       default:
1633         return FALSE;
1634
1635       case 128:         /* Linux/MIPS elf_prpsinfo */
1636         elf_tdata (abfd)->core_program
1637          = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
1638         elf_tdata (abfd)->core_command
1639          = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
1640     }
1641
1642   /* Note that for some reason, a spurious space is tacked
1643      onto the end of the args in some (at least one anyway)
1644      implementations, so strip it off if it exists.  */
1645
1646   {
1647     char *command = elf_tdata (abfd)->core_command;
1648     int n = strlen (command);
1649
1650     if (0 < n && command[n - 1] == ' ')
1651       command[n - 1] = '\0';
1652   }
1653
1654   return TRUE;
1655 }
1656 \f
1657 /* Depending on the target vector we generate some version of Irix
1658    executables or "normal" MIPS ELF ABI executables.  */
1659 static irix_compat_t
1660 elf32_mips_irix_compat (abfd)
1661      bfd *abfd;
1662 {
1663   if ((abfd->xvec == &bfd_elf32_bigmips_vec)
1664       || (abfd->xvec == &bfd_elf32_littlemips_vec))
1665     return ict_irix5;
1666   else
1667     return ict_none;
1668 }
1669 \f
1670 /* Given a data section and an in-memory embedded reloc section, store
1671    relocation information into the embedded reloc section which can be
1672    used at runtime to relocate the data section.  This is called by the
1673    linker when the --embedded-relocs switch is used.  This is called
1674    after the add_symbols entry point has been called for all the
1675    objects, and before the final_link entry point is called.  */
1676
1677 bfd_boolean
1678 bfd_mips_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
1679      bfd *abfd;
1680      struct bfd_link_info *info;
1681      asection *datasec;
1682      asection *relsec;
1683      char **errmsg;
1684 {
1685   Elf_Internal_Shdr *symtab_hdr;
1686   Elf_Internal_Sym *isymbuf = NULL;
1687   Elf_Internal_Rela *internal_relocs = NULL;
1688   Elf_Internal_Rela *irel, *irelend;
1689   bfd_byte *p;
1690
1691   BFD_ASSERT (! info->relocateable);
1692
1693   *errmsg = NULL;
1694
1695   if (datasec->reloc_count == 0)
1696     return TRUE;
1697
1698   /* Read this BFD's symbols if we haven't done so already, or get the cached
1699      copy if it exists.  */
1700   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1701   if (symtab_hdr->sh_info != 0)
1702     {
1703       isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1704       if (isymbuf == NULL)
1705         isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1706                                         symtab_hdr->sh_info, 0,
1707                                         NULL, NULL, NULL);
1708       if (isymbuf == NULL)
1709         goto error_return;
1710     }
1711
1712   /* Get a copy of the native relocations.  */
1713   internal_relocs = (_bfd_elf_link_read_relocs
1714                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1715                       info->keep_memory));
1716   if (internal_relocs == NULL)
1717     goto error_return;
1718
1719   relsec->contents = (bfd_byte *) bfd_alloc (abfd, datasec->reloc_count * 12);
1720   if (relsec->contents == NULL)
1721     goto error_return;
1722
1723   p = relsec->contents;
1724
1725   irelend = internal_relocs + datasec->reloc_count;
1726
1727   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
1728     {
1729       asection *targetsec;
1730
1731       /* We are going to write a four byte longword into the runtime
1732          reloc section.  The longword will be the address in the data
1733          section which must be relocated.  It is followed by the name
1734          of the target section NUL-padded or truncated to 8
1735          characters.  */
1736
1737       /* We can only relocate absolute longword relocs at run time.  */
1738       if ((ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_32) &&
1739           (ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_64))
1740         {
1741           *errmsg = _("unsupported reloc type");
1742           bfd_set_error (bfd_error_bad_value);
1743           goto error_return;
1744         }
1745       /* Get the target section referred to by the reloc.  */
1746       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1747         {
1748           Elf_Internal_Sym *isym;
1749
1750           /* A local symbol.  */
1751           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1752           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1753         }
1754       else
1755         {
1756           unsigned long indx;
1757           struct elf_link_hash_entry *h;
1758
1759           /* An external symbol.  */
1760           indx = ELF32_R_SYM (irel->r_info);
1761           h = elf_sym_hashes (abfd)[indx];
1762           targetsec = NULL;
1763           /*
1764              For some reason, in certain programs, the symbol will
1765              not be in the hash table.  It seems to happen when you
1766              declare a static table of pointers to const external structures.
1767              In this case, the relocs are relative to data, not
1768              text, so just treating it like an undefined link
1769              should be sufficient.  */
1770           BFD_ASSERT(h != NULL);
1771           if (h->root.type == bfd_link_hash_defined
1772               || h->root.type == bfd_link_hash_defweak)
1773             targetsec = h->root.u.def.section;
1774         }
1775
1776
1777       /*
1778          Set the low bit of the relocation offset if it's a MIPS64 reloc.
1779          Relocations will always be on (at least) 32-bit boundaries.  */
1780
1781       bfd_put_32 (abfd, ((irel->r_offset + datasec->output_offset) +
1782                   ((ELF32_R_TYPE (irel->r_info) == (int) R_MIPS_64) ? 1 : 0)),
1783                   p);
1784       memset (p + 4, 0, 8);
1785       if (targetsec != NULL)
1786         strncpy (p + 4, targetsec->output_section->name, 8);
1787     }
1788
1789   if (internal_relocs != NULL
1790       && elf_section_data (datasec)->relocs != internal_relocs)
1791     free (internal_relocs);
1792   if (isymbuf != NULL
1793       && symtab_hdr->contents != (unsigned char *) isymbuf)
1794     free (isymbuf);
1795   return TRUE;
1796
1797  error_return:
1798   if (internal_relocs != NULL
1799       && elf_section_data (datasec)->relocs != internal_relocs)
1800     free (internal_relocs);
1801   if (isymbuf != NULL
1802       && symtab_hdr->contents != (unsigned char *) isymbuf)
1803     free (isymbuf);
1804   return FALSE;
1805 }
1806 \f
1807 /* ECOFF swapping routines.  These are used when dealing with the
1808    .mdebug section, which is in the ECOFF debugging format.  */
1809 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
1810   /* Symbol table magic number.  */
1811   magicSym,
1812   /* Alignment of debugging information.  E.g., 4.  */
1813   4,
1814   /* Sizes of external symbolic information.  */
1815   sizeof (struct hdr_ext),
1816   sizeof (struct dnr_ext),
1817   sizeof (struct pdr_ext),
1818   sizeof (struct sym_ext),
1819   sizeof (struct opt_ext),
1820   sizeof (struct fdr_ext),
1821   sizeof (struct rfd_ext),
1822   sizeof (struct ext_ext),
1823   /* Functions to swap in external symbolic data.  */
1824   ecoff_swap_hdr_in,
1825   ecoff_swap_dnr_in,
1826   ecoff_swap_pdr_in,
1827   ecoff_swap_sym_in,
1828   ecoff_swap_opt_in,
1829   ecoff_swap_fdr_in,
1830   ecoff_swap_rfd_in,
1831   ecoff_swap_ext_in,
1832   _bfd_ecoff_swap_tir_in,
1833   _bfd_ecoff_swap_rndx_in,
1834   /* Functions to swap out external symbolic data.  */
1835   ecoff_swap_hdr_out,
1836   ecoff_swap_dnr_out,
1837   ecoff_swap_pdr_out,
1838   ecoff_swap_sym_out,
1839   ecoff_swap_opt_out,
1840   ecoff_swap_fdr_out,
1841   ecoff_swap_rfd_out,
1842   ecoff_swap_ext_out,
1843   _bfd_ecoff_swap_tir_out,
1844   _bfd_ecoff_swap_rndx_out,
1845   /* Function to read in symbolic data.  */
1846   _bfd_mips_elf_read_ecoff_info
1847 };
1848 \f
1849 #define ELF_ARCH                        bfd_arch_mips
1850 #define ELF_MACHINE_CODE                EM_MIPS
1851
1852 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
1853    a value of 0x1000, and we are compatible.  */
1854 #define ELF_MAXPAGESIZE                 0x1000
1855
1856 #define elf_backend_collect             TRUE
1857 #define elf_backend_type_change_ok      TRUE
1858 #define elf_backend_can_gc_sections     TRUE
1859 #define elf_info_to_howto               mips_info_to_howto_rela
1860 #define elf_info_to_howto_rel           mips_info_to_howto_rel
1861 #define elf_backend_sym_is_global       mips_elf_sym_is_global
1862 #define elf_backend_object_p            mips_elf32_object_p
1863 #define elf_backend_symbol_processing   _bfd_mips_elf_symbol_processing
1864 #define elf_backend_section_processing  _bfd_mips_elf_section_processing
1865 #define elf_backend_section_from_shdr   _bfd_mips_elf_section_from_shdr
1866 #define elf_backend_fake_sections       _bfd_mips_elf_fake_sections
1867 #define elf_backend_section_from_bfd_section \
1868                                         _bfd_mips_elf_section_from_bfd_section
1869 #define elf_backend_add_symbol_hook     _bfd_mips_elf_add_symbol_hook
1870 #define elf_backend_link_output_symbol_hook \
1871                                         _bfd_mips_elf_link_output_symbol_hook
1872 #define elf_backend_create_dynamic_sections \
1873                                         _bfd_mips_elf_create_dynamic_sections
1874 #define elf_backend_check_relocs        _bfd_mips_elf_check_relocs
1875 #define elf_backend_adjust_dynamic_symbol \
1876                                         _bfd_mips_elf_adjust_dynamic_symbol
1877 #define elf_backend_always_size_sections \
1878                                         _bfd_mips_elf_always_size_sections
1879 #define elf_backend_size_dynamic_sections \
1880                                         _bfd_mips_elf_size_dynamic_sections
1881 #define elf_backend_relocate_section    _bfd_mips_elf_relocate_section
1882 #define elf_backend_finish_dynamic_symbol \
1883                                         _bfd_mips_elf_finish_dynamic_symbol
1884 #define elf_backend_finish_dynamic_sections \
1885                                         _bfd_mips_elf_finish_dynamic_sections
1886 #define elf_backend_final_write_processing \
1887                                         _bfd_mips_elf_final_write_processing
1888 #define elf_backend_additional_program_headers \
1889                                         _bfd_mips_elf_additional_program_headers
1890 #define elf_backend_modify_segment_map  _bfd_mips_elf_modify_segment_map
1891 #define elf_backend_gc_mark_hook        _bfd_mips_elf_gc_mark_hook
1892 #define elf_backend_gc_sweep_hook       _bfd_mips_elf_gc_sweep_hook
1893 #define elf_backend_copy_indirect_symbol \
1894                                         _bfd_mips_elf_copy_indirect_symbol
1895 #define elf_backend_hide_symbol         _bfd_mips_elf_hide_symbol
1896 #define elf_backend_grok_prstatus       elf32_mips_grok_prstatus
1897 #define elf_backend_grok_psinfo         elf32_mips_grok_psinfo
1898 #define elf_backend_ecoff_debug_swap    &mips_elf32_ecoff_debug_swap
1899
1900 #define elf_backend_got_header_size     (4 * MIPS_RESERVED_GOTNO)
1901 #define elf_backend_plt_header_size     0
1902 #define elf_backend_may_use_rel_p       1
1903 #define elf_backend_may_use_rela_p      0
1904 #define elf_backend_default_use_rela_p  0
1905 #define elf_backend_sign_extend_vma     TRUE
1906
1907 #define elf_backend_discard_info        _bfd_mips_elf_discard_info
1908 #define elf_backend_ignore_discarded_relocs \
1909                                         _bfd_mips_elf_ignore_discarded_relocs
1910 #define elf_backend_mips_irix_compat    elf32_mips_irix_compat
1911 #define elf_backend_mips_rtype_to_howto mips_elf32_rtype_to_howto
1912 #define bfd_elf32_bfd_is_local_label_name \
1913                                         mips_elf_is_local_label_name
1914 #define bfd_elf32_find_nearest_line     _bfd_mips_elf_find_nearest_line
1915 #define bfd_elf32_new_section_hook      _bfd_mips_elf_new_section_hook
1916 #define bfd_elf32_set_section_contents  _bfd_mips_elf_set_section_contents
1917 #define bfd_elf32_bfd_get_relocated_section_contents \
1918                                 _bfd_elf_mips_get_relocated_section_contents
1919 #define bfd_elf32_bfd_link_hash_table_create \
1920                                         _bfd_mips_elf_link_hash_table_create
1921 #define bfd_elf32_bfd_final_link        _bfd_mips_elf_final_link
1922 #define bfd_elf32_bfd_merge_private_bfd_data \
1923                                         _bfd_mips_elf_merge_private_bfd_data
1924 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
1925 #define bfd_elf32_bfd_print_private_bfd_data \
1926                                         _bfd_mips_elf_print_private_bfd_data
1927
1928 /* Support for SGI-ish mips targets.  */
1929 #define TARGET_LITTLE_SYM               bfd_elf32_littlemips_vec
1930 #define TARGET_LITTLE_NAME              "elf32-littlemips"
1931 #define TARGET_BIG_SYM                  bfd_elf32_bigmips_vec
1932 #define TARGET_BIG_NAME                 "elf32-bigmips"
1933
1934 #include "elf32-target.h"
1935
1936 /* Support for traditional mips targets.  */
1937 #define INCLUDED_TARGET_FILE            /* More a type of flag.  */
1938
1939 #undef TARGET_LITTLE_SYM
1940 #undef TARGET_LITTLE_NAME
1941 #undef TARGET_BIG_SYM
1942 #undef TARGET_BIG_NAME
1943
1944 #define TARGET_LITTLE_SYM               bfd_elf32_tradlittlemips_vec
1945 #define TARGET_LITTLE_NAME              "elf32-tradlittlemips"
1946 #define TARGET_BIG_SYM                  bfd_elf32_tradbigmips_vec
1947 #define TARGET_BIG_NAME                 "elf32-tradbigmips"
1948
1949 /* Include the target file again for this target.  */
1950 #include "elf32-target.h"