contrib/binutils/bfd/coff-mips.c

   1 /* BFD back-end for MIPS Extended-Coff files.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5    Original version by Per Bothner.
   6    Full support added by Ian Lance Taylor, ian@cygnus.com.
   7
   8 This file is part of BFD, the Binary File Descriptor library.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "coff/internal.h"
  29 #include "coff/sym.h"
  30 #include "coff/symconst.h"
  31 #include "coff/ecoff.h"
  32 #include "coff/mips.h"
  33 #include "libcoff.h"
  34 #include "libecoff.h"
  35 \f
  36 /* Prototypes for static functions.  */
  37
  38 static bfd_boolean mips_ecoff_bad_format_hook
  39   PARAMS ((bfd *abfd, PTR filehdr));
  40 static void mips_ecoff_swap_reloc_in
  41   PARAMS ((bfd *, PTR, struct internal_reloc *));
  42 static void mips_ecoff_swap_reloc_out
  43   PARAMS ((bfd *, const struct internal_reloc *, PTR));
  44 static void mips_adjust_reloc_in
  45   PARAMS ((bfd *, const struct internal_reloc *, arelent *));
  46 static void mips_adjust_reloc_out
  47   PARAMS ((bfd *, const arelent *, struct internal_reloc *));
  48 static bfd_reloc_status_type mips_generic_reloc
  49   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  50            asection *section, bfd *output_bfd, char **error));
  51 static bfd_reloc_status_type mips_refhi_reloc
  52   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  53            asection *section, bfd *output_bfd, char **error));
  54 static bfd_reloc_status_type mips_reflo_reloc
  55   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  56            asection *section, bfd *output_bfd, char **error));
  57 static bfd_reloc_status_type mips_gprel_reloc
  58   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  59            asection *section, bfd *output_bfd, char **error));
  60 static bfd_reloc_status_type mips_relhi_reloc
  61   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  62            asection *section, bfd *output_bfd, char **error));
  63 static bfd_reloc_status_type mips_rello_reloc
  64   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  65            asection *section, bfd *output_bfd, char **error));
  66 static bfd_reloc_status_type mips_switch_reloc
  67   PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
  68            asection *section, bfd *output_bfd, char **error));
  69 static void mips_relocate_hi
  70   PARAMS ((struct internal_reloc *refhi, struct internal_reloc *reflo,
  71            bfd *input_bfd, asection *input_section, bfd_byte *contents,
  72            size_t adjust, bfd_vma relocation, bfd_boolean pcrel));
  73 static bfd_boolean mips_relocate_section
  74   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));
  75 static bfd_boolean mips_read_relocs
  76   PARAMS ((bfd *, asection *));
  77 static bfd_boolean mips_relax_section
  78   PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
  79 static bfd_boolean mips_relax_pcrel16
  80   PARAMS ((struct bfd_link_info *, bfd *, asection *,
  81            struct ecoff_link_hash_entry *, bfd_byte *, bfd_vma));
  82 static reloc_howto_type *mips_bfd_reloc_type_lookup
  83   PARAMS ((bfd *, bfd_reloc_code_real_type));
  84 \f
  85 /* ECOFF has COFF sections, but the debugging information is stored in
  86    a completely different format.  ECOFF targets use some of the
  87    swapping routines from coffswap.h, and some of the generic COFF
  88    routines in coffgen.c, but, unlike the real COFF targets, do not
  89    use coffcode.h itself.
  90
  91    Get the generic COFF swapping routines, except for the reloc,
  92    symbol, and lineno ones.  Give them ECOFF names.  */
  93 #define MIPSECOFF
  94 #define NO_COFF_RELOCS
  95 #define NO_COFF_SYMBOLS
  96 #define NO_COFF_LINENOS
  97 #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
  98 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
  99 #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
 100 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
 101 #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
 102 #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
 103 #include "coffswap.h"
 104
 105 /* Get the ECOFF swapping routines.  */
 106 #define ECOFF_32
 107 #include "ecoffswap.h"
 108 \f
 109 /* How to process the various relocs types.  */
 110
 111 static reloc_howto_type mips_howto_table[] =
 112 {
 113   /* Reloc type 0 is ignored.  The reloc reading code ensures that
 114      this is a reference to the .abs section, which will cause
 115      bfd_perform_relocation to do nothing.  */
 116   HOWTO (MIPS_R_IGNORE, /* type */
 117          0,                     /* rightshift */
 118          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 119          8,                     /* bitsize */
 120          FALSE,                 /* pc_relative */
 121          0,                     /* bitpos */
 122          complain_overflow_dont, /* complain_on_overflow */
 123          0,                     /* special_function */
 124          "IGNORE",              /* name */
 125          FALSE,                 /* partial_inplace */
 126          0,                     /* src_mask */
 127          0,                     /* dst_mask */
 128          FALSE),                /* pcrel_offset */
 129
 130   /* A 16 bit reference to a symbol, normally from a data section.  */
 131   HOWTO (MIPS_R_REFHALF,        /* type */
 132          0,                     /* rightshift */
 133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 134          16,                    /* bitsize */
 135          FALSE,                 /* pc_relative */
 136          0,                     /* bitpos */
 137          complain_overflow_bitfield, /* complain_on_overflow */
 138          mips_generic_reloc,    /* special_function */
 139          "REFHALF",             /* name */
 140          TRUE,                  /* partial_inplace */
 141          0xffff,                /* src_mask */
 142          0xffff,                /* dst_mask */
 143          FALSE),                /* pcrel_offset */
 144
 145   /* A 32 bit reference to a symbol, normally from a data section.  */
 146   HOWTO (MIPS_R_REFWORD,        /* type */
 147          0,                     /* rightshift */
 148          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          32,                    /* bitsize */
 150          FALSE,                 /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_bitfield, /* complain_on_overflow */
 153          mips_generic_reloc,    /* special_function */
 154          "REFWORD",             /* name */
 155          TRUE,                  /* partial_inplace */
 156          0xffffffff,            /* src_mask */
 157          0xffffffff,            /* dst_mask */
 158          FALSE),                /* pcrel_offset */
 159
 160   /* A 26 bit absolute jump address.  */
 161   HOWTO (MIPS_R_JMPADDR,        /* type */
 162          2,                     /* rightshift */
 163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          26,                    /* bitsize */
 165          FALSE,                 /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_dont, /* complain_on_overflow */
 168                                 /* This needs complex overflow
 169                                    detection, because the upper four
 170                                    bits must match the PC.  */
 171          mips_generic_reloc,    /* special_function */
 172          "JMPADDR",             /* name */
 173          TRUE,                  /* partial_inplace */
 174          0x3ffffff,             /* src_mask */
 175          0x3ffffff,             /* dst_mask */
 176          FALSE),                /* pcrel_offset */
 177
 178   /* The high 16 bits of a symbol value.  Handled by the function
 179      mips_refhi_reloc.  */
 180   HOWTO (MIPS_R_REFHI,          /* type */
 181          16,                    /* rightshift */
 182          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 183          16,                    /* bitsize */
 184          FALSE,                 /* pc_relative */
 185          0,                     /* bitpos */
 186          complain_overflow_bitfield, /* complain_on_overflow */
 187          mips_refhi_reloc,      /* special_function */
 188          "REFHI",               /* name */
 189          TRUE,                  /* partial_inplace */
 190          0xffff,                /* src_mask */
 191          0xffff,                /* dst_mask */
 192          FALSE),                /* pcrel_offset */
 193
 194   /* The low 16 bits of a symbol value.  */
 195   HOWTO (MIPS_R_REFLO,          /* type */
 196          0,                     /* rightshift */
 197          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 198          16,                    /* bitsize */
 199          FALSE,                 /* pc_relative */
 200          0,                     /* bitpos */
 201          complain_overflow_dont, /* complain_on_overflow */
 202          mips_reflo_reloc,      /* special_function */
 203          "REFLO",               /* name */
 204          TRUE,                  /* partial_inplace */
 205          0xffff,                /* src_mask */
 206          0xffff,                /* dst_mask */
 207          FALSE),                /* pcrel_offset */
 208
 209   /* A reference to an offset from the gp register.  Handled by the
 210      function mips_gprel_reloc.  */
 211   HOWTO (MIPS_R_GPREL,          /* type */
 212          0,                     /* rightshift */
 213          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 214          16,                    /* bitsize */
 215          FALSE,                 /* pc_relative */
 216          0,                     /* bitpos */
 217          complain_overflow_signed, /* complain_on_overflow */
 218          mips_gprel_reloc,      /* special_function */
 219          "GPREL",               /* name */
 220          TRUE,                  /* partial_inplace */
 221          0xffff,                /* src_mask */
 222          0xffff,                /* dst_mask */
 223          FALSE),                /* pcrel_offset */
 224
 225   /* A reference to a literal using an offset from the gp register.
 226      Handled by the function mips_gprel_reloc.  */
 227   HOWTO (MIPS_R_LITERAL,        /* type */
 228          0,                     /* rightshift */
 229          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          16,                    /* bitsize */
 231          FALSE,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_signed, /* complain_on_overflow */
 234          mips_gprel_reloc,      /* special_function */
 235          "LITERAL",             /* name */
 236          TRUE,                  /* partial_inplace */
 237          0xffff,                /* src_mask */
 238          0xffff,                /* dst_mask */
 239          FALSE),                /* pcrel_offset */
 240
 241   EMPTY_HOWTO (8),
 242   EMPTY_HOWTO (9),
 243   EMPTY_HOWTO (10),
 244   EMPTY_HOWTO (11),
 245
 246   /* This reloc is a Cygnus extension used when generating position
 247      independent code for embedded systems.  It represents a 16 bit PC
 248      relative reloc rightshifted twice as used in the MIPS branch
 249      instructions.  */
 250   HOWTO (MIPS_R_PCREL16,        /* type */
 251          2,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          16,                    /* bitsize */
 254          TRUE,                  /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_signed, /* complain_on_overflow */
 257          mips_generic_reloc,    /* special_function */
 258          "PCREL16",             /* name */
 259          TRUE,                  /* partial_inplace */
 260          0xffff,                /* src_mask */
 261          0xffff,                /* dst_mask */
 262          TRUE),                 /* pcrel_offset */
 263
 264   /* This reloc is a Cygnus extension used when generating position
 265      independent code for embedded systems.  It represents the high 16
 266      bits of a PC relative reloc.  The next reloc must be
 267      MIPS_R_RELLO, and the addend is formed from the addends of the
 268      two instructions, just as in MIPS_R_REFHI and MIPS_R_REFLO.  The
 269      final value is actually PC relative to the location of the
 270      MIPS_R_RELLO reloc, not the MIPS_R_RELHI reloc.  */
 271   HOWTO (MIPS_R_RELHI,          /* type */
 272          16,                    /* rightshift */
 273          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 274          16,                    /* bitsize */
 275          TRUE,                  /* pc_relative */
 276          0,                     /* bitpos */
 277          complain_overflow_bitfield, /* complain_on_overflow */
 278          mips_relhi_reloc,      /* special_function */
 279          "RELHI",               /* name */
 280          TRUE,                  /* partial_inplace */
 281          0xffff,                /* src_mask */
 282          0xffff,                /* dst_mask */
 283          TRUE),                 /* pcrel_offset */
 284
 285   /* This reloc is a Cygnus extension used when generating position
 286      independent code for embedded systems.  It represents the low 16
 287      bits of a PC relative reloc.  */
 288   HOWTO (MIPS_R_RELLO,          /* type */
 289          0,                     /* rightshift */
 290          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 291          16,                    /* bitsize */
 292          TRUE,                  /* pc_relative */
 293          0,                     /* bitpos */
 294          complain_overflow_dont, /* complain_on_overflow */
 295          mips_rello_reloc,      /* special_function */
 296          "RELLO",               /* name */
 297          TRUE,                  /* partial_inplace */
 298          0xffff,                /* src_mask */
 299          0xffff,                /* dst_mask */
 300          TRUE),                 /* pcrel_offset */
 301
 302   EMPTY_HOWTO (15),
 303   EMPTY_HOWTO (16),
 304   EMPTY_HOWTO (17),
 305   EMPTY_HOWTO (18),
 306   EMPTY_HOWTO (19),
 307   EMPTY_HOWTO (20),
 308   EMPTY_HOWTO (21),
 309
 310   /* This reloc is a Cygnus extension used when generating position
 311      independent code for embedded systems.  It represents an entry in
 312      a switch table, which is the difference between two symbols in
 313      the .text section.  The symndx is actually the offset from the
 314      reloc address to the subtrahend.  See include/coff/mips.h for
 315      more details.  */
 316   HOWTO (MIPS_R_SWITCH,         /* type */
 317          0,                     /* rightshift */
 318          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          32,                    /* bitsize */
 320          TRUE,                  /* pc_relative */
 321          0,                     /* bitpos */
 322          complain_overflow_dont, /* complain_on_overflow */
 323          mips_switch_reloc,     /* special_function */
 324          "SWITCH",              /* name */
 325          TRUE,                  /* partial_inplace */
 326          0xffffffff,            /* src_mask */
 327          0xffffffff,            /* dst_mask */
 328          TRUE)                  /* pcrel_offset */
 329 };
 330
 331 #define MIPS_HOWTO_COUNT \
 332   (sizeof mips_howto_table / sizeof mips_howto_table[0])
 333
 334 /* When the linker is doing relaxing, it may change an external PCREL16
 335    reloc.  This typically represents an instruction like
 336        bal foo
 337    We change it to
 338        .set  noreorder
 339        bal   $L1
 340        lui   $at,%hi(foo - $L1)
 341      $L1:
 342        addiu $at,%lo(foo - $L1)
 343        addu  $at,$at,$31
 344        jalr  $at
 345    PCREL16_EXPANSION_ADJUSTMENT is the number of bytes this changes the
 346    instruction by.  */
 347
 348 #define PCREL16_EXPANSION_ADJUSTMENT (4 * 4)
 349 \f
 350 /* See whether the magic number matches.  */
 351
 352 static bfd_boolean
 353 mips_ecoff_bad_format_hook (abfd, filehdr)
 354      bfd *abfd;
 355      PTR filehdr;
 356 {
 357   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 358
 359   switch (internal_f->f_magic)
 360     {
 361     case MIPS_MAGIC_1:
 362       /* I don't know what endianness this implies.  */
 363       return TRUE;
 364
 365     case MIPS_MAGIC_BIG:
 366     case MIPS_MAGIC_BIG2:
 367     case MIPS_MAGIC_BIG3:
 368       return bfd_big_endian (abfd);
 369
 370     case MIPS_MAGIC_LITTLE:
 371     case MIPS_MAGIC_LITTLE2:
 372     case MIPS_MAGIC_LITTLE3:
 373       return bfd_little_endian (abfd);
 374
 375     default:
 376       return FALSE;
 377     }
 378 }
 379 \f
 380 /* Reloc handling.  MIPS ECOFF relocs are packed into 8 bytes in
 381    external form.  They use a bit which indicates whether the symbol
 382    is external.  */
 383
 384 /* Swap a reloc in.  */
 385
 386 static void
 387 mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
 388      bfd *abfd;
 389      PTR ext_ptr;
 390      struct internal_reloc *intern;
 391 {
 392   const RELOC *ext = (RELOC *) ext_ptr;
 393
 394   intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
 395   if (bfd_header_big_endian (abfd))
 396     {
 397       intern->r_symndx = (((int) ext->r_bits[0]
 398                            << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
 399                           | ((int) ext->r_bits[1]
 400                              << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
 401                           | ((int) ext->r_bits[2]
 402                              << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
 403       intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
 404                         >> RELOC_BITS3_TYPE_SH_BIG);
 405       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
 406     }
 407   else
 408     {
 409       intern->r_symndx = (((int) ext->r_bits[0]
 410                            << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
 411                           | ((int) ext->r_bits[1]
 412                              << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
 413                           | ((int) ext->r_bits[2]
 414                              << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
 415       intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
 416                          >> RELOC_BITS3_TYPE_SH_LITTLE)
 417                         | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
 418                            << RELOC_BITS3_TYPEHI_SH_LITTLE));
 419       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
 420     }
 421
 422   /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
 423      MIPS_R_RELLO reloc, r_symndx is actually the offset from the
 424      reloc address to the base of the difference (see
 425      include/coff/mips.h for more details).  We copy symndx into the
 426      r_offset field so as not to confuse ecoff_slurp_reloc_table in
 427      ecoff.c.  In adjust_reloc_in we then copy r_offset into the reloc
 428      addend.  */
 429   if (intern->r_type == MIPS_R_SWITCH
 430       || (! intern->r_extern
 431           && (intern->r_type == MIPS_R_RELLO
 432               || intern->r_type == MIPS_R_RELHI)))
 433     {
 434       BFD_ASSERT (! intern->r_extern);
 435       intern->r_offset = intern->r_symndx;
 436       if (intern->r_offset & 0x800000)
 437         intern->r_offset -= 0x1000000;
 438       intern->r_symndx = RELOC_SECTION_TEXT;
 439     }
 440 }
 441
 442 /* Swap a reloc out.  */
 443
 444 static void
 445 mips_ecoff_swap_reloc_out (abfd, intern, dst)
 446      bfd *abfd;
 447      const struct internal_reloc *intern;
 448      PTR dst;
 449 {
 450   RELOC *ext = (RELOC *) dst;
 451   long r_symndx;
 452
 453   BFD_ASSERT (intern->r_extern
 454               || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
 455
 456   /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELLO or
 457      MIPS_R_RELHI reloc, we actually want to write the contents of
 458      r_offset out as the symbol index.  This undoes the change made by
 459      mips_ecoff_swap_reloc_in.  */
 460   if (intern->r_type != MIPS_R_SWITCH
 461       && (intern->r_extern
 462           || (intern->r_type != MIPS_R_RELHI
 463               && intern->r_type != MIPS_R_RELLO)))
 464     r_symndx = intern->r_symndx;
 465   else
 466     {
 467       BFD_ASSERT (intern->r_symndx == RELOC_SECTION_TEXT);
 468       r_symndx = intern->r_offset & 0xffffff;
 469     }
 470
 471   H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
 472   if (bfd_header_big_endian (abfd))
 473     {
 474       ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
 475       ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
 476       ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
 477       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
 478                          & RELOC_BITS3_TYPE_BIG)
 479                         | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
 480     }
 481   else
 482     {
 483       ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
 484       ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
 485       ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
 486       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
 487                          & RELOC_BITS3_TYPE_LITTLE)
 488                         | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
 489                             & RELOC_BITS3_TYPEHI_LITTLE))
 490                         | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
 491     }
 492 }
 493
 494 /* Finish canonicalizing a reloc.  Part of this is generic to all
 495    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 496    this backend routine.  It must fill in the howto field.  */
 497
 498 static void
 499 mips_adjust_reloc_in (abfd, intern, rptr)
 500      bfd *abfd;
 501      const struct internal_reloc *intern;
 502      arelent *rptr;
 503 {
 504   if (intern->r_type > MIPS_R_SWITCH)
 505     abort ();
 506
 507   if (! intern->r_extern
 508       && (intern->r_type == MIPS_R_GPREL
 509           || intern->r_type == MIPS_R_LITERAL))
 510     rptr->addend += ecoff_data (abfd)->gp;
 511
 512   /* If the type is MIPS_R_IGNORE, make sure this is a reference to
 513      the absolute section so that the reloc is ignored.  */
 514   if (intern->r_type == MIPS_R_IGNORE)
 515     rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 516
 517   /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
 518      MIPS_R_RELLO reloc, we want the addend field of the BFD relocto
 519      hold the value which was originally in the symndx field of the
 520      internal MIPS ECOFF reloc.  This value was copied into
 521      intern->r_offset by mips_swap_reloc_in, and here we copy it into
 522      the addend field.  */
 523   if (intern->r_type == MIPS_R_SWITCH
 524       || (! intern->r_extern
 525           && (intern->r_type == MIPS_R_RELHI
 526               || intern->r_type == MIPS_R_RELLO)))
 527     rptr->addend = intern->r_offset;
 528
 529   rptr->howto = &mips_howto_table[intern->r_type];
 530 }
 531
 532 /* Make any adjustments needed to a reloc before writing it out.  None
 533    are needed for MIPS.  */
 534
 535 static void
 536 mips_adjust_reloc_out (abfd, rel, intern)
 537      bfd *abfd ATTRIBUTE_UNUSED;
 538      const arelent *rel;
 539      struct internal_reloc *intern;
 540 {
 541   /* For a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
 542      MIPS_R_RELLO reloc, we must copy rel->addend into
 543      intern->r_offset.  This will then be written out as the symbol
 544      index by mips_ecoff_swap_reloc_out.  This operation parallels the
 545      action of mips_adjust_reloc_in.  */
 546   if (intern->r_type == MIPS_R_SWITCH
 547       || (! intern->r_extern
 548           && (intern->r_type == MIPS_R_RELHI
 549               || intern->r_type == MIPS_R_RELLO)))
 550     intern->r_offset = rel->addend;
 551 }
 552
 553 /* ECOFF relocs are either against external symbols, or against
 554    sections.  If we are producing relocatable output, and the reloc
 555    is against an external symbol, and nothing has given us any
 556    additional addend, the resulting reloc will also be against the
 557    same symbol.  In such a case, we don't want to change anything
 558    about the way the reloc is handled, since it will all be done at
 559    final link time.  Rather than put special case code into
 560    bfd_perform_relocation, all the reloc types use this howto
 561    function.  It just short circuits the reloc if producing
 562    relocatable output against an external symbol.  */
 563
 564 static bfd_reloc_status_type
 565 mips_generic_reloc (abfd,
 566                     reloc_entry,
 567                     symbol,
 568                     data,
 569                     input_section,
 570                     output_bfd,
 571                     error_message)
 572      bfd *abfd ATTRIBUTE_UNUSED;
 573      arelent *reloc_entry;
 574      asymbol *symbol;
 575      PTR data ATTRIBUTE_UNUSED;
 576      asection *input_section;
 577      bfd *output_bfd;
 578      char **error_message ATTRIBUTE_UNUSED;
 579 {
 580   if (output_bfd != (bfd *) NULL
 581       && (symbol->flags & BSF_SECTION_SYM) == 0
 582       && reloc_entry->addend == 0)
 583     {
 584       reloc_entry->address += input_section->output_offset;
 585       return bfd_reloc_ok;
 586     }
 587
 588   return bfd_reloc_continue;
 589 }
 590
 591 /* Do a REFHI relocation.  This has to be done in combination with a
 592    REFLO reloc, because there is a carry from the REFLO to the REFHI.
 593    Here we just save the information we need; we do the actual
 594    relocation when we see the REFLO.  MIPS ECOFF requires that the
 595    REFLO immediately follow the REFHI.  As a GNU extension, we permit
 596    an arbitrary number of HI relocs to be associated with a single LO
 597    reloc.  This extension permits gcc to output the HI and LO relocs
 598    itself.  */
 599
 600 struct mips_hi
 601 {
 602   struct mips_hi *next;
 603   bfd_byte *addr;
 604   bfd_vma addend;
 605 };
 606
 607 /* FIXME: This should not be a static variable.  */
 608
 609 static struct mips_hi *mips_refhi_list;
 610
 611 static bfd_reloc_status_type
 612 mips_refhi_reloc (abfd,
 613                   reloc_entry,
 614                   symbol,
 615                   data,
 616                   input_section,
 617                   output_bfd,
 618                   error_message)
 619      bfd *abfd ATTRIBUTE_UNUSED;
 620      arelent *reloc_entry;
 621      asymbol *symbol;
 622      PTR data;
 623      asection *input_section;
 624      bfd *output_bfd;
 625      char **error_message ATTRIBUTE_UNUSED;
 626 {
 627   bfd_reloc_status_type ret;
 628   bfd_vma relocation;
 629   struct mips_hi *n;
 630
 631   /* If we're relocating, and this an external symbol, we don't want
 632      to change anything.  */
 633   if (output_bfd != (bfd *) NULL
 634       && (symbol->flags & BSF_SECTION_SYM) == 0
 635       && reloc_entry->addend == 0)
 636     {
 637       reloc_entry->address += input_section->output_offset;
 638       return bfd_reloc_ok;
 639     }
 640
 641   ret = bfd_reloc_ok;
 642   if (bfd_is_und_section (symbol->section)
 643       && output_bfd == (bfd *) NULL)
 644     ret = bfd_reloc_undefined;
 645
 646   if (bfd_is_com_section (symbol->section))
 647     relocation = 0;
 648   else
 649     relocation = symbol->value;
 650
 651   relocation += symbol->section->output_section->vma;
 652   relocation += symbol->section->output_offset;
 653   relocation += reloc_entry->addend;
 654
 655   if (reloc_entry->address > input_section->_cooked_size)
 656     return bfd_reloc_outofrange;
 657
 658   /* Save the information, and let REFLO do the actual relocation.  */
 659   n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
 660   if (n == NULL)
 661     return bfd_reloc_outofrange;
 662   n->addr = (bfd_byte *) data + reloc_entry->address;
 663   n->addend = relocation;
 664   n->next = mips_refhi_list;
 665   mips_refhi_list = n;
 666
 667   if (output_bfd != (bfd *) NULL)
 668     reloc_entry->address += input_section->output_offset;
 669
 670   return ret;
 671 }
 672
 673 /* Do a REFLO relocation.  This is a straightforward 16 bit inplace
 674    relocation; this function exists in order to do the REFHI
 675    relocation described above.  */
 676
 677 static bfd_reloc_status_type
 678 mips_reflo_reloc (abfd,
 679                   reloc_entry,
 680                   symbol,
 681                   data,
 682                   input_section,
 683                   output_bfd,
 684                   error_message)
 685      bfd *abfd;
 686      arelent *reloc_entry;
 687      asymbol *symbol;
 688      PTR data;
 689      asection *input_section;
 690      bfd *output_bfd;
 691      char **error_message;
 692 {
 693   if (mips_refhi_list != NULL)
 694     {
 695       struct mips_hi *l;
 696
 697       l = mips_refhi_list;
 698       while (l != NULL)
 699         {
 700           unsigned long insn;
 701           unsigned long val;
 702           unsigned long vallo;
 703           struct mips_hi *next;
 704
 705           /* Do the REFHI relocation.  Note that we actually don't
 706              need to know anything about the REFLO itself, except
 707              where to find the low 16 bits of the addend needed by the
 708              REFHI.  */
 709           insn = bfd_get_32 (abfd, l->addr);
 710           vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
 711                    & 0xffff);
 712           val = ((insn & 0xffff) << 16) + vallo;
 713           val += l->addend;
 714
 715           /* The low order 16 bits are always treated as a signed
 716              value.  Therefore, a negative value in the low order bits
 717              requires an adjustment in the high order bits.  We need
 718              to make this adjustment in two ways: once for the bits we
 719              took from the data, and once for the bits we are putting
 720              back in to the data.  */
 721           if ((vallo & 0x8000) != 0)
 722             val -= 0x10000;
 723           if ((val & 0x8000) != 0)
 724             val += 0x10000;
 725
 726           insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
 727           bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
 728
 729           next = l->next;
 730           free (l);
 731           l = next;
 732         }
 733
 734       mips_refhi_list = NULL;
 735     }
 736
 737   /* Now do the REFLO reloc in the usual way.  */
 738   return mips_generic_reloc (abfd, reloc_entry, symbol, data,
 739                               input_section, output_bfd, error_message);
 740 }
 741
 742 /* Do a GPREL relocation.  This is a 16 bit value which must become
 743    the offset from the gp register.  */
 744
 745 static bfd_reloc_status_type
 746 mips_gprel_reloc (abfd,
 747                   reloc_entry,
 748                   symbol,
 749                   data,
 750                   input_section,
 751                   output_bfd,
 752                   error_message)
 753      bfd *abfd;
 754      arelent *reloc_entry;
 755      asymbol *symbol;
 756      PTR data;
 757      asection *input_section;
 758      bfd *output_bfd;
 759      char **error_message;
 760 {
 761   bfd_boolean relocatable;
 762   bfd_vma gp;
 763   bfd_vma relocation;
 764   unsigned long val;
 765   unsigned long insn;
 766
 767   /* If we're relocating, and this is an external symbol with no
 768      addend, we don't want to change anything.  We will only have an
 769      addend if this is a newly created reloc, not read from an ECOFF
 770      file.  */
 771   if (output_bfd != (bfd *) NULL
 772       && (symbol->flags & BSF_SECTION_SYM) == 0
 773       && reloc_entry->addend == 0)
 774     {
 775       reloc_entry->address += input_section->output_offset;
 776       return bfd_reloc_ok;
 777     }
 778
 779   if (output_bfd != (bfd *) NULL)
 780     relocatable = TRUE;
 781   else
 782     {
 783       relocatable = FALSE;
 784       output_bfd = symbol->section->output_section->owner;
 785     }
 786
 787   if (bfd_is_und_section (symbol->section) && ! relocatable)
 788     return bfd_reloc_undefined;
 789
 790   /* We have to figure out the gp value, so that we can adjust the
 791      symbol value correctly.  We look up the symbol _gp in the output
 792      BFD.  If we can't find it, we're stuck.  We cache it in the ECOFF
 793      target data.  We don't need to adjust the symbol value for an
 794      external symbol if we are producing relocatable output.  */
 795   gp = _bfd_get_gp_value (output_bfd);
 796   if (gp == 0
 797       && (! relocatable
 798           || (symbol->flags & BSF_SECTION_SYM) != 0))
 799     {
 800       if (relocatable)
 801         {
 802           /* Make up a value.  */
 803           gp = symbol->section->output_section->vma + 0x4000;
 804           _bfd_set_gp_value (output_bfd, gp);
 805         }
 806       else
 807         {
 808           unsigned int count;
 809           asymbol **sym;
 810           unsigned int i;
 811
 812           count = bfd_get_symcount (output_bfd);
 813           sym = bfd_get_outsymbols (output_bfd);
 814
 815           if (sym == (asymbol **) NULL)
 816             i = count;
 817           else
 818             {
 819               for (i = 0; i < count; i++, sym++)
 820                 {
 821                   register const char *name;
 822
 823                   name = bfd_asymbol_name (*sym);
 824                   if (*name == '_' && strcmp (name, "_gp") == 0)
 825                     {
 826                       gp = bfd_asymbol_value (*sym);
 827                       _bfd_set_gp_value (output_bfd, gp);
 828                       break;
 829                     }
 830                 }
 831             }
 832
 833           if (i >= count)
 834             {
 835               /* Only get the error once.  */
 836               gp = 4;
 837               _bfd_set_gp_value (output_bfd, gp);
 838               *error_message =
 839                 (char *) _("GP relative relocation when _gp not defined");
 840               return bfd_reloc_dangerous;
 841             }
 842         }
 843     }
 844
 845   if (bfd_is_com_section (symbol->section))
 846     relocation = 0;
 847   else
 848     relocation = symbol->value;
 849
 850   relocation += symbol->section->output_section->vma;
 851   relocation += symbol->section->output_offset;
 852
 853   if (reloc_entry->address > input_section->_cooked_size)
 854     return bfd_reloc_outofrange;
 855
 856   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 857
 858   /* Set val to the offset into the section or symbol.  */
 859   val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
 860   if (val & 0x8000)
 861     val -= 0x10000;
 862
 863   /* Adjust val for the final section location and GP value.  If we
 864      are producing relocatable output, we don't want to do this for
 865      an external symbol.  */
 866   if (! relocatable
 867       || (symbol->flags & BSF_SECTION_SYM) != 0)
 868     val += relocation - gp;
 869
 870   insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
 871   bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
 872
 873   if (relocatable)
 874     reloc_entry->address += input_section->output_offset;
 875
 876   /* Make sure it fit in 16 bits.  */
 877   if ((long) val >= 0x8000 || (long) val < -0x8000)
 878     return bfd_reloc_overflow;
 879
 880   return bfd_reloc_ok;
 881 }
 882
 883 /* Do a RELHI relocation.  We do this in conjunction with a RELLO
 884    reloc, just as REFHI and REFLO are done together.  RELHI and RELLO
 885    are Cygnus extensions used when generating position independent
 886    code for embedded systems.  */
 887
 888 /* FIXME: This should not be a static variable.  */
 889
 890 static struct mips_hi *mips_relhi_list;
 891
 892 static bfd_reloc_status_type
 893 mips_relhi_reloc (abfd,
 894                   reloc_entry,
 895                   symbol,
 896                   data,
 897                   input_section,
 898                   output_bfd,
 899                   error_message)
 900      bfd *abfd ATTRIBUTE_UNUSED;
 901      arelent *reloc_entry;
 902      asymbol *symbol;
 903      PTR data;
 904      asection *input_section;
 905      bfd *output_bfd;
 906      char **error_message ATTRIBUTE_UNUSED;
 907 {
 908   bfd_reloc_status_type ret;
 909   bfd_vma relocation;
 910   struct mips_hi *n;
 911
 912   /* If this is a reloc against a section symbol, then it is correct
 913      in the object file.  The only time we want to change this case is
 914      when we are relaxing, and that is handled entirely by
 915      mips_relocate_section and never calls this function.  */
 916   if ((symbol->flags & BSF_SECTION_SYM) != 0)
 917     {
 918       if (output_bfd != (bfd *) NULL)
 919         reloc_entry->address += input_section->output_offset;
 920       return bfd_reloc_ok;
 921     }
 922
 923   /* This is an external symbol.  If we're relocating, we don't want
 924      to change anything.  */
 925   if (output_bfd != (bfd *) NULL)
 926     {
 927       reloc_entry->address += input_section->output_offset;
 928       return bfd_reloc_ok;
 929     }
 930
 931   ret = bfd_reloc_ok;
 932   if (bfd_is_und_section (symbol->section)
 933       && output_bfd == (bfd *) NULL)
 934     ret = bfd_reloc_undefined;
 935
 936   if (bfd_is_com_section (symbol->section))
 937     relocation = 0;
 938   else
 939     relocation = symbol->value;
 940
 941   relocation += symbol->section->output_section->vma;
 942   relocation += symbol->section->output_offset;
 943   relocation += reloc_entry->addend;
 944
 945   if (reloc_entry->address > input_section->_cooked_size)
 946     return bfd_reloc_outofrange;
 947
 948   /* Save the information, and let RELLO do the actual relocation.  */
 949   n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
 950   if (n == NULL)
 951     return bfd_reloc_outofrange;
 952   n->addr = (bfd_byte *) data + reloc_entry->address;
 953   n->addend = relocation;
 954   n->next = mips_relhi_list;
 955   mips_relhi_list = n;
 956
 957   if (output_bfd != (bfd *) NULL)
 958     reloc_entry->address += input_section->output_offset;
 959
 960   return ret;
 961 }
 962
 963 /* Do a RELLO relocation.  This is a straightforward 16 bit PC
 964    relative relocation; this function exists in order to do the RELHI
 965    relocation described above.  */
 966
 967 static bfd_reloc_status_type
 968 mips_rello_reloc (abfd,
 969                   reloc_entry,
 970                   symbol,
 971                   data,
 972                   input_section,
 973                   output_bfd,
 974                   error_message)
 975      bfd *abfd;
 976      arelent *reloc_entry;
 977      asymbol *symbol;
 978      PTR data;
 979      asection *input_section;
 980      bfd *output_bfd;
 981      char **error_message;
 982 {
 983   if (mips_relhi_list != NULL)
 984     {
 985       struct mips_hi *l;
 986
 987       l = mips_relhi_list;
 988       while (l != NULL)
 989         {
 990           unsigned long insn;
 991           unsigned long val;
 992           unsigned long vallo;
 993           struct mips_hi *next;
 994
 995           /* Do the RELHI relocation.  Note that we actually don't
 996              need to know anything about the RELLO itself, except
 997              where to find the low 16 bits of the addend needed by the
 998              RELHI.  */
 999           insn = bfd_get_32 (abfd, l->addr);
1000           vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1001                    & 0xffff);
1002           val = ((insn & 0xffff) << 16) + vallo;
1003           val += l->addend;
1004
1005           /* If the symbol is defined, make val PC relative.  If the
1006              symbol is not defined we don't want to do this, because
1007              we don't want the value in the object file to incorporate
1008              the address of the reloc.  */
1009           if (! bfd_is_und_section (bfd_get_section (symbol))
1010               && ! bfd_is_com_section (bfd_get_section (symbol)))
1011             val -= (input_section->output_section->vma
1012                     + input_section->output_offset
1013                     + reloc_entry->address);
1014
1015           /* The low order 16 bits are always treated as a signed
1016              value.  Therefore, a negative value in the low order bits
1017              requires an adjustment in the high order bits.  We need
1018              to make this adjustment in two ways: once for the bits we
1019              took from the data, and once for the bits we are putting
1020              back in to the data.  */
1021           if ((vallo & 0x8000) != 0)
1022             val -= 0x10000;
1023           if ((val & 0x8000) != 0)
1024             val += 0x10000;
1025
1026           insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
1027           bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
1028
1029           next = l->next;
1030           free (l);
1031           l = next;
1032         }
1033
1034       mips_relhi_list = NULL;
1035     }
1036
1037   /* If this is a reloc against a section symbol, then it is correct
1038      in the object file.  The only time we want to change this case is
1039      when we are relaxing, and that is handled entirely by
1040      mips_relocate_section and never calls this function.  */
1041   if ((symbol->flags & BSF_SECTION_SYM) != 0)
1042     {
1043       if (output_bfd != (bfd *) NULL)
1044         reloc_entry->address += input_section->output_offset;
1045       return bfd_reloc_ok;
1046     }
1047
1048   /* bfd_perform_relocation does not handle pcrel_offset relocations
1049      correctly when generating a relocatable file, so handle them
1050      directly here.  */
1051   if (output_bfd != (bfd *) NULL)
1052     {
1053       reloc_entry->address += input_section->output_offset;
1054       return bfd_reloc_ok;
1055     }
1056
1057   /* Now do the RELLO reloc in the usual way.  */
1058   return mips_generic_reloc (abfd, reloc_entry, symbol, data,
1059                               input_section, output_bfd, error_message);
1060 }
1061
1062 /* This is the special function for the MIPS_R_SWITCH reloc.  This
1063    special reloc is normally correct in the object file, and only
1064    requires special handling when relaxing.  We don't want
1065    bfd_perform_relocation to tamper with it at all.  */
1066
1067 static bfd_reloc_status_type
1068 mips_switch_reloc (abfd,
1069                    reloc_entry,
1070                    symbol,
1071                    data,
1072                    input_section,
1073                    output_bfd,
1074                    error_message)
1075      bfd *abfd ATTRIBUTE_UNUSED;
1076      arelent *reloc_entry ATTRIBUTE_UNUSED;
1077      asymbol *symbol ATTRIBUTE_UNUSED;
1078      PTR data ATTRIBUTE_UNUSED;
1079      asection *input_section ATTRIBUTE_UNUSED;
1080      bfd *output_bfd ATTRIBUTE_UNUSED;
1081      char **error_message ATTRIBUTE_UNUSED;
1082 {
1083   return bfd_reloc_ok;
1084 }
1085
1086 /* Get the howto structure for a generic reloc type.  */
1087
1088 static reloc_howto_type *
1089 mips_bfd_reloc_type_lookup (abfd, code)
1090      bfd *abfd ATTRIBUTE_UNUSED;
1091      bfd_reloc_code_real_type code;
1092 {
1093   int mips_type;
1094
1095   switch (code)
1096     {
1097     case BFD_RELOC_16:
1098       mips_type = MIPS_R_REFHALF;
1099       break;
1100     case BFD_RELOC_32:
1101     case BFD_RELOC_CTOR:
1102       mips_type = MIPS_R_REFWORD;
1103       break;
1104     case BFD_RELOC_MIPS_JMP:
1105       mips_type = MIPS_R_JMPADDR;
1106       break;
1107     case BFD_RELOC_HI16_S:
1108       mips_type = MIPS_R_REFHI;
1109       break;
1110     case BFD_RELOC_LO16:
1111       mips_type = MIPS_R_REFLO;
1112       break;
1113     case BFD_RELOC_GPREL16:
1114       mips_type = MIPS_R_GPREL;
1115       break;
1116     case BFD_RELOC_MIPS_LITERAL:
1117       mips_type = MIPS_R_LITERAL;
1118       break;
1119     case BFD_RELOC_16_PCREL_S2:
1120       mips_type = MIPS_R_PCREL16;
1121       break;
1122     case BFD_RELOC_PCREL_HI16_S:
1123       mips_type = MIPS_R_RELHI;
1124       break;
1125     case BFD_RELOC_PCREL_LO16:
1126       mips_type = MIPS_R_RELLO;
1127       break;
1128     case BFD_RELOC_GPREL32:
1129       mips_type = MIPS_R_SWITCH;
1130       break;
1131     default:
1132       return (reloc_howto_type *) NULL;
1133     }
1134
1135   return &mips_howto_table[mips_type];
1136 }
1137 \f
1138 /* A helper routine for mips_relocate_section which handles the REFHI
1139    and RELHI relocations.  The REFHI relocation must be followed by a
1140    REFLO relocation (and RELHI by a RELLO), and the addend used is
1141    formed from the addends of both instructions.  */
1142
1143 static void
1144 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents, adjust,
1145                   relocation, pcrel)
1146      struct internal_reloc *refhi;
1147      struct internal_reloc *reflo;
1148      bfd *input_bfd;
1149      asection *input_section;
1150      bfd_byte *contents;
1151      size_t adjust;
1152      bfd_vma relocation;
1153      bfd_boolean pcrel;
1154 {
1155   unsigned long insn;
1156   unsigned long val;
1157   unsigned long vallo;
1158
1159   if (refhi == NULL)
1160     return;
1161
1162   insn = bfd_get_32 (input_bfd,
1163                      contents + adjust + refhi->r_vaddr - input_section->vma);
1164   if (reflo == NULL)
1165     vallo = 0;
1166   else
1167     vallo = (bfd_get_32 (input_bfd,
1168                          contents + adjust + reflo->r_vaddr - input_section->vma)
1169              & 0xffff);
1170
1171   val = ((insn & 0xffff) << 16) + vallo;
1172   val += relocation;
1173
1174   /* The low order 16 bits are always treated as a signed value.
1175      Therefore, a negative value in the low order bits requires an
1176      adjustment in the high order bits.  We need to make this
1177      adjustment in two ways: once for the bits we took from the data,
1178      and once for the bits we are putting back in to the data.  */
1179   if ((vallo & 0x8000) != 0)
1180     val -= 0x10000;
1181
1182   if (pcrel)
1183     val -= (input_section->output_section->vma
1184             + input_section->output_offset
1185             + (reflo->r_vaddr - input_section->vma + adjust));
1186
1187   if ((val & 0x8000) != 0)
1188     val += 0x10000;
1189
1190   insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
1191   bfd_put_32 (input_bfd, (bfd_vma) insn,
1192               contents + adjust + refhi->r_vaddr - input_section->vma);
1193 }
1194
1195 /* Relocate a section while linking a MIPS ECOFF file.  */
1196
1197 static bfd_boolean
1198 mips_relocate_section (output_bfd, info, input_bfd, input_section,
1199                        contents, external_relocs)
1200      bfd *output_bfd;
1201      struct bfd_link_info *info;
1202      bfd *input_bfd;
1203      asection *input_section;
1204      bfd_byte *contents;
1205      PTR external_relocs;
1206 {
1207   asection **symndx_to_section;
1208   struct ecoff_link_hash_entry **sym_hashes;
1209   bfd_vma gp;
1210   bfd_boolean gp_undefined;
1211   size_t adjust;
1212   long *offsets;
1213   struct external_reloc *ext_rel;
1214   struct external_reloc *ext_rel_end;
1215   unsigned int i;
1216   bfd_boolean got_lo;
1217   struct internal_reloc lo_int_rel;
1218   bfd_size_type amt;
1219
1220   BFD_ASSERT (input_bfd->xvec->byteorder
1221               == output_bfd->xvec->byteorder);
1222
1223   /* We keep a table mapping the symndx found in an internal reloc to
1224      the appropriate section.  This is faster than looking up the
1225      section by name each time.  */
1226   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1227   if (symndx_to_section == (asection **) NULL)
1228     {
1229       amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1230       symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1231       if (!symndx_to_section)
1232         return FALSE;
1233
1234       symndx_to_section[RELOC_SECTION_NONE] = NULL;
1235       symndx_to_section[RELOC_SECTION_TEXT] =
1236         bfd_get_section_by_name (input_bfd, ".text");
1237       symndx_to_section[RELOC_SECTION_RDATA] =
1238         bfd_get_section_by_name (input_bfd, ".rdata");
1239       symndx_to_section[RELOC_SECTION_DATA] =
1240         bfd_get_section_by_name (input_bfd, ".data");
1241       symndx_to_section[RELOC_SECTION_SDATA] =
1242         bfd_get_section_by_name (input_bfd, ".sdata");
1243       symndx_to_section[RELOC_SECTION_SBSS] =
1244         bfd_get_section_by_name (input_bfd, ".sbss");
1245       symndx_to_section[RELOC_SECTION_BSS] =
1246         bfd_get_section_by_name (input_bfd, ".bss");
1247       symndx_to_section[RELOC_SECTION_INIT] =
1248         bfd_get_section_by_name (input_bfd, ".init");
1249       symndx_to_section[RELOC_SECTION_LIT8] =
1250         bfd_get_section_by_name (input_bfd, ".lit8");
1251       symndx_to_section[RELOC_SECTION_LIT4] =
1252         bfd_get_section_by_name (input_bfd, ".lit4");
1253       symndx_to_section[RELOC_SECTION_XDATA] = NULL;
1254       symndx_to_section[RELOC_SECTION_PDATA] = NULL;
1255       symndx_to_section[RELOC_SECTION_FINI] =
1256         bfd_get_section_by_name (input_bfd, ".fini");
1257       symndx_to_section[RELOC_SECTION_LITA] = NULL;
1258       symndx_to_section[RELOC_SECTION_ABS] = NULL;
1259
1260       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1261     }
1262
1263   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1264
1265   gp = _bfd_get_gp_value (output_bfd);
1266   if (gp == 0)
1267     gp_undefined = TRUE;
1268   else
1269     gp_undefined = FALSE;
1270
1271   got_lo = FALSE;
1272
1273   adjust = 0;
1274
1275   if (ecoff_section_data (input_bfd, input_section) == NULL)
1276     offsets = NULL;
1277   else
1278     offsets = ecoff_section_data (input_bfd, input_section)->offsets;
1279
1280   ext_rel = (struct external_reloc *) external_relocs;
1281   ext_rel_end = ext_rel + input_section->reloc_count;
1282   for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1283     {
1284       struct internal_reloc int_rel;
1285       bfd_boolean use_lo = FALSE;
1286       bfd_vma addend;
1287       reloc_howto_type *howto;
1288       struct ecoff_link_hash_entry *h = NULL;
1289       asection *s = NULL;
1290       bfd_vma relocation;
1291       bfd_reloc_status_type r;
1292
1293       if (! got_lo)
1294         mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
1295       else
1296         {
1297           int_rel = lo_int_rel;
1298           got_lo = FALSE;
1299         }
1300
1301       BFD_ASSERT (int_rel.r_type
1302                   < sizeof mips_howto_table / sizeof mips_howto_table[0]);
1303
1304       /* The REFHI and RELHI relocs requires special handling.  they
1305          must be followed by a REFLO or RELLO reloc, respectively, and
1306          the addend is formed from both relocs.  */
1307       if (int_rel.r_type == MIPS_R_REFHI
1308           || int_rel.r_type == MIPS_R_RELHI)
1309         {
1310           struct external_reloc *lo_ext_rel;
1311
1312           /* As a GNU extension, permit an arbitrary number of REFHI
1313              or RELHI relocs before the REFLO or RELLO reloc.  This
1314              permits gcc to emit the HI and LO relocs itself.  */
1315           for (lo_ext_rel = ext_rel + 1;
1316                lo_ext_rel < ext_rel_end;
1317                lo_ext_rel++)
1318             {
1319               mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
1320                                         &lo_int_rel);
1321               if (lo_int_rel.r_type != int_rel.r_type)
1322                 break;
1323             }
1324
1325           if (lo_ext_rel < ext_rel_end
1326               && (lo_int_rel.r_type
1327                   == (int_rel.r_type == MIPS_R_REFHI
1328                       ? MIPS_R_REFLO
1329                       : MIPS_R_RELLO))
1330               && int_rel.r_extern == lo_int_rel.r_extern
1331               && int_rel.r_symndx == lo_int_rel.r_symndx)
1332             {
1333               use_lo = TRUE;
1334               if (lo_ext_rel == ext_rel + 1)
1335                 got_lo = TRUE;
1336             }
1337         }
1338
1339       howto = &mips_howto_table[int_rel.r_type];
1340
1341       /* The SWITCH reloc must be handled specially.  This reloc is
1342          marks the location of a difference between two portions of an
1343          object file.  The symbol index does not reference a symbol,
1344          but is actually the offset from the reloc to the subtrahend
1345          of the difference.  This reloc is correct in the object file,
1346          and needs no further adjustment, unless we are relaxing.  If
1347          we are relaxing, we may have to add in an offset.  Since no
1348          symbols are involved in this reloc, we handle it completely
1349          here.  */
1350       if (int_rel.r_type == MIPS_R_SWITCH)
1351         {
1352           if (offsets != NULL
1353               && offsets[i] != 0)
1354             {
1355               r = _bfd_relocate_contents (howto, input_bfd,
1356                                           (bfd_vma) offsets[i],
1357                                           (contents
1358                                            + adjust
1359                                            + int_rel.r_vaddr
1360                                            - input_section->vma));
1361               BFD_ASSERT (r == bfd_reloc_ok);
1362             }
1363
1364           continue;
1365         }
1366
1367       if (int_rel.r_extern)
1368         {
1369           h = sym_hashes[int_rel.r_symndx];
1370           /* If h is NULL, that means that there is a reloc against an
1371              external symbol which we thought was just a debugging
1372              symbol.  This should not happen.  */
1373           if (h == (struct ecoff_link_hash_entry *) NULL)
1374             abort ();
1375         }
1376       else
1377         {
1378           if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
1379             s = NULL;
1380           else
1381             s = symndx_to_section[int_rel.r_symndx];
1382
1383           if (s == (asection *) NULL)
1384             abort ();
1385         }
1386
1387       /* The GPREL reloc uses an addend: the difference in the GP
1388          values.  */
1389       if (int_rel.r_type != MIPS_R_GPREL
1390           && int_rel.r_type != MIPS_R_LITERAL)
1391         addend = 0;
1392       else
1393         {
1394           if (gp_undefined)
1395             {
1396               if (! ((*info->callbacks->reloc_dangerous)
1397                      (info, _("GP relative relocation used when GP not defined"),
1398                       input_bfd, input_section,
1399                       int_rel.r_vaddr - input_section->vma)))
1400                 return FALSE;
1401               /* Only give the error once per link.  */
1402               gp = 4;
1403               _bfd_set_gp_value (output_bfd, gp);
1404               gp_undefined = FALSE;
1405             }
1406           if (! int_rel.r_extern)
1407             {
1408               /* This is a relocation against a section.  The current
1409                  addend in the instruction is the difference between
1410                  INPUT_SECTION->vma and the GP value of INPUT_BFD.  We
1411                  must change this to be the difference between the
1412                  final definition (which will end up in RELOCATION)
1413                  and the GP value of OUTPUT_BFD (which is in GP).  */
1414               addend = ecoff_data (input_bfd)->gp - gp;
1415             }
1416           else if (! info->relocatable
1417                    || h->root.type == bfd_link_hash_defined
1418                    || h->root.type == bfd_link_hash_defweak)
1419             {
1420               /* This is a relocation against a defined symbol.  The
1421                  current addend in the instruction is simply the
1422                  desired offset into the symbol (normally zero).  We
1423                  are going to change this into a relocation against a
1424                  defined symbol, so we want the instruction to hold
1425                  the difference between the final definition of the
1426                  symbol (which will end up in RELOCATION) and the GP
1427                  value of OUTPUT_BFD (which is in GP).  */
1428               addend = - gp;
1429             }
1430           else
1431             {
1432               /* This is a relocation against an undefined or common
1433                  symbol.  The current addend in the instruction is
1434                  simply the desired offset into the symbol (normally
1435                  zero).  We are generating relocatable output, and we
1436                  aren't going to define this symbol, so we just leave
1437                  the instruction alone.  */
1438               addend = 0;
1439             }
1440         }
1441
1442       /* If we are relaxing, mips_relax_section may have set
1443          offsets[i] to some value.  A value of 1 means we must expand
1444          a PC relative branch into a multi-instruction of sequence,
1445          and any other value is an addend.  */
1446       if (offsets != NULL
1447           && offsets[i] != 0)
1448         {
1449           BFD_ASSERT (! info->relocatable);
1450           BFD_ASSERT (int_rel.r_type == MIPS_R_PCREL16
1451                       || int_rel.r_type == MIPS_R_RELHI
1452                       || int_rel.r_type == MIPS_R_RELLO);
1453           if (offsets[i] != 1)
1454             addend += offsets[i];
1455           else
1456             {
1457               bfd_byte *here;
1458
1459               BFD_ASSERT (int_rel.r_extern
1460                           && int_rel.r_type == MIPS_R_PCREL16);
1461
1462               /* Move the rest of the instructions up.  */
1463               here = (contents
1464                       + adjust
1465                       + int_rel.r_vaddr
1466                       - input_section->vma);
1467               memmove (here + PCREL16_EXPANSION_ADJUSTMENT, here,
1468                        (size_t) (input_section->_raw_size
1469                                  - (int_rel.r_vaddr - input_section->vma)));
1470
1471               /* Generate the new instructions.  */
1472               if (! mips_relax_pcrel16 (info, input_bfd, input_section,
1473                                         h, here,
1474                                         (input_section->output_section->vma
1475                                          + input_section->output_offset
1476                                          + (int_rel.r_vaddr
1477                                             - input_section->vma)
1478                                          + adjust)))
1479                 return FALSE;
1480
1481               /* We must adjust everything else up a notch.  */
1482               adjust += PCREL16_EXPANSION_ADJUSTMENT;
1483
1484               /* mips_relax_pcrel16 handles all the details of this
1485                  relocation.  */
1486               continue;
1487             }
1488         }
1489
1490       /* If we are relaxing, and this is a reloc against the .text
1491          segment, we may need to adjust it if some branches have been
1492          expanded.  The reloc types which are likely to occur in the
1493          .text section are handled efficiently by mips_relax_section,
1494          and thus do not need to be handled here.  */
1495       if (ecoff_data (input_bfd)->debug_info.adjust != NULL
1496           && ! int_rel.r_extern
1497           && int_rel.r_symndx == RELOC_SECTION_TEXT
1498           && (strcmp (bfd_get_section_name (input_bfd, input_section),
1499                       ".text") != 0
1500               || (int_rel.r_type != MIPS_R_PCREL16
1501                   && int_rel.r_type != MIPS_R_SWITCH
1502                   && int_rel.r_type != MIPS_R_RELHI
1503                   && int_rel.r_type != MIPS_R_RELLO)))
1504         {
1505           bfd_vma adr;
1506           struct ecoff_value_adjust *a;
1507
1508           /* We need to get the addend so that we know whether we need
1509              to adjust the address.  */
1510           BFD_ASSERT (int_rel.r_type == MIPS_R_REFWORD);
1511
1512           adr = bfd_get_32 (input_bfd,
1513                             (contents
1514                              + adjust
1515                              + int_rel.r_vaddr
1516                              - input_section->vma));
1517
1518           for (a = ecoff_data (input_bfd)->debug_info.adjust;
1519                a != (struct ecoff_value_adjust *) NULL;
1520                a = a->next)
1521             {
1522               if (adr >= a->start && adr < a->end)
1523                 addend += a->adjust;
1524             }
1525         }
1526
1527       if (info->relocatable)
1528         {
1529           /* We are generating relocatable output, and must convert
1530              the existing reloc.  */
1531           if (int_rel.r_extern)
1532             {
1533               if ((h->root.type == bfd_link_hash_defined
1534                    || h->root.type == bfd_link_hash_defweak)
1535                   && ! bfd_is_abs_section (h->root.u.def.section))
1536                 {
1537                   const char *name;
1538
1539                   /* This symbol is defined in the output.  Convert
1540                      the reloc from being against the symbol to being
1541                      against the section.  */
1542
1543                   /* Clear the r_extern bit.  */
1544                   int_rel.r_extern = 0;
1545
1546                   /* Compute a new r_symndx value.  */
1547                   s = h->root.u.def.section;
1548                   name = bfd_get_section_name (output_bfd,
1549                                                s->output_section);
1550
1551                   int_rel.r_symndx = -1;
1552                   switch (name[1])
1553                     {
1554                     case 'b':
1555                       if (strcmp (name, ".bss") == 0)
1556                         int_rel.r_symndx = RELOC_SECTION_BSS;
1557                       break;
1558                     case 'd':
1559                       if (strcmp (name, ".data") == 0)
1560                         int_rel.r_symndx = RELOC_SECTION_DATA;
1561                       break;
1562                     case 'f':
1563                       if (strcmp (name, ".fini") == 0)
1564                         int_rel.r_symndx = RELOC_SECTION_FINI;
1565                       break;
1566                     case 'i':
1567                       if (strcmp (name, ".init") == 0)
1568                         int_rel.r_symndx = RELOC_SECTION_INIT;
1569                       break;
1570                     case 'l':
1571                       if (strcmp (name, ".lit8") == 0)
1572                         int_rel.r_symndx = RELOC_SECTION_LIT8;
1573                       else if (strcmp (name, ".lit4") == 0)
1574                         int_rel.r_symndx = RELOC_SECTION_LIT4;
1575                       break;
1576                     case 'r':
1577                       if (strcmp (name, ".rdata") == 0)
1578                         int_rel.r_symndx = RELOC_SECTION_RDATA;
1579                       break;
1580                     case 's':
1581                       if (strcmp (name, ".sdata") == 0)
1582                         int_rel.r_symndx = RELOC_SECTION_SDATA;
1583                       else if (strcmp (name, ".sbss") == 0)
1584                         int_rel.r_symndx = RELOC_SECTION_SBSS;
1585                       break;
1586                     case 't':
1587                       if (strcmp (name, ".text") == 0)
1588                         int_rel.r_symndx = RELOC_SECTION_TEXT;
1589                       break;
1590                     }
1591
1592                   if (int_rel.r_symndx == -1)
1593                     abort ();
1594
1595                   /* Add the section VMA and the symbol value.  */
1596                   relocation = (h->root.u.def.value
1597                                 + s->output_section->vma
1598                                 + s->output_offset);
1599
1600                   /* For a PC relative relocation, the object file
1601                      currently holds just the addend.  We must adjust
1602                      by the address to get the right value.  */
1603                   if (howto->pc_relative)
1604                     {
1605                       relocation -= int_rel.r_vaddr - input_section->vma;
1606
1607                       /* If we are converting a RELHI or RELLO reloc
1608                          from being against an external symbol to
1609                          being against a section, we must put a
1610                          special value into the r_offset field.  This
1611                          value is the old addend.  The r_offset for
1612                          both the RELHI and RELLO relocs are the same,
1613                          and we set both when we see RELHI.  */
1614                       if (int_rel.r_type == MIPS_R_RELHI)
1615                         {
1616                           long addhi, addlo;
1617
1618                           addhi = bfd_get_32 (input_bfd,
1619                                               (contents
1620                                                + adjust
1621                                                + int_rel.r_vaddr
1622                                                - input_section->vma));
1623                           addhi &= 0xffff;
1624                           if (addhi & 0x8000)
1625                             addhi -= 0x10000;
1626                           addhi <<= 16;
1627
1628                           if (! use_lo)
1629                             addlo = 0;
1630                           else
1631                             {
1632                               addlo = bfd_get_32 (input_bfd,
1633                                                   (contents
1634                                                    + adjust
1635                                                    + lo_int_rel.r_vaddr
1636                                                    - input_section->vma));
1637                               addlo &= 0xffff;
1638                               if (addlo & 0x8000)
1639                                 addlo -= 0x10000;
1640
1641                               lo_int_rel.r_offset = addhi + addlo;
1642                             }
1643
1644                           int_rel.r_offset = addhi + addlo;
1645                         }
1646                     }
1647
1648                   h = NULL;
1649                 }
1650               else
1651                 {
1652                   /* Change the symndx value to the right one for the
1653                      output BFD.  */
1654                   int_rel.r_symndx = h->indx;
1655                   if (int_rel.r_symndx == -1)
1656                     {
1657                       /* This symbol is not being written out.  */
1658                       if (! ((*info->callbacks->unattached_reloc)
1659                              (info, h->root.root.string, input_bfd,
1660                               input_section,
1661                               int_rel.r_vaddr - input_section->vma)))
1662                         return FALSE;
1663                       int_rel.r_symndx = 0;
1664                     }
1665                   relocation = 0;
1666                 }
1667             }
1668           else
1669             {
1670               /* This is a relocation against a section.  Adjust the
1671                  value by the amount the section moved.  */
1672               relocation = (s->output_section->vma
1673                             + s->output_offset
1674                             - s->vma);
1675             }
1676
1677           relocation += addend;
1678           addend = 0;
1679
1680           /* Adjust a PC relative relocation by removing the reference
1681              to the original address in the section and including the
1682              reference to the new address.  However, external RELHI
1683              and RELLO relocs are PC relative, but don't include any
1684              reference to the address.  The addend is merely an
1685              addend.  */
1686           if (howto->pc_relative
1687               && (! int_rel.r_extern
1688                   || (int_rel.r_type != MIPS_R_RELHI
1689                       && int_rel.r_type != MIPS_R_RELLO)))
1690             relocation -= (input_section->output_section->vma
1691                            + input_section->output_offset
1692                            - input_section->vma);
1693
1694           /* Adjust the contents.  */
1695           if (relocation == 0)
1696             r = bfd_reloc_ok;
1697           else
1698             {
1699               if (int_rel.r_type != MIPS_R_REFHI
1700                   && int_rel.r_type != MIPS_R_RELHI)
1701                 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1702                                             (contents
1703                                              + adjust
1704                                              + int_rel.r_vaddr
1705                                              - input_section->vma));
1706               else
1707                 {
1708                   mips_relocate_hi (&int_rel,
1709                                     use_lo ? &lo_int_rel : NULL,
1710                                     input_bfd, input_section, contents,
1711                                     adjust, relocation,
1712                                     int_rel.r_type == MIPS_R_RELHI);
1713                   r = bfd_reloc_ok;
1714                 }
1715             }
1716
1717           /* Adjust the reloc address.  */
1718           int_rel.r_vaddr += (input_section->output_section->vma
1719                               + input_section->output_offset
1720                               - input_section->vma);
1721
1722           /* Save the changed reloc information.  */
1723           mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1724         }
1725       else
1726         {
1727           /* We are producing a final executable.  */
1728           if (int_rel.r_extern)
1729             {
1730               /* This is a reloc against a symbol.  */
1731               if (h->root.type == bfd_link_hash_defined
1732                   || h->root.type == bfd_link_hash_defweak)
1733                 {
1734                   asection *hsec;
1735
1736                   hsec = h->root.u.def.section;
1737                   relocation = (h->root.u.def.value
1738                                 + hsec->output_section->vma
1739                                 + hsec->output_offset);
1740                 }
1741               else
1742                 {
1743                   if (! ((*info->callbacks->undefined_symbol)
1744                          (info, h->root.root.string, input_bfd,
1745                           input_section,
1746                           int_rel.r_vaddr - input_section->vma, TRUE)))
1747                     return FALSE;
1748                   relocation = 0;
1749                 }
1750             }
1751           else
1752             {
1753               /* This is a reloc against a section.  */
1754               relocation = (s->output_section->vma
1755                             + s->output_offset
1756                             - s->vma);
1757
1758               /* A PC relative reloc is already correct in the object
1759                  file.  Make it look like a pcrel_offset relocation by
1760                  adding in the start address.  */
1761               if (howto->pc_relative)
1762                 {
1763                   if (int_rel.r_type != MIPS_R_RELHI || ! use_lo)
1764                     relocation += int_rel.r_vaddr + adjust;
1765                   else
1766                     relocation += lo_int_rel.r_vaddr + adjust;
1767                 }
1768             }
1769
1770           if (int_rel.r_type != MIPS_R_REFHI
1771               && int_rel.r_type != MIPS_R_RELHI)
1772             r = _bfd_final_link_relocate (howto,
1773                                           input_bfd,
1774                                           input_section,
1775                                           contents,
1776                                           (int_rel.r_vaddr
1777                                            - input_section->vma
1778                                            + adjust),
1779                                           relocation,
1780                                           addend);
1781           else
1782             {
1783               mips_relocate_hi (&int_rel,
1784                                 use_lo ? &lo_int_rel : NULL,
1785                                 input_bfd, input_section, contents, adjust,
1786                                 relocation,
1787                                 int_rel.r_type == MIPS_R_RELHI);
1788               r = bfd_reloc_ok;
1789             }
1790         }
1791
1792       /* MIPS_R_JMPADDR requires peculiar overflow detection.  The
1793          instruction provides a 28 bit address (the two lower bits are
1794          implicit zeroes) which is combined with the upper four bits
1795          of the instruction address.  */
1796       if (r == bfd_reloc_ok
1797           && int_rel.r_type == MIPS_R_JMPADDR
1798           && (((relocation
1799                 + addend
1800                 + (int_rel.r_extern ? 0 : s->vma))
1801                & 0xf0000000)
1802               != ((input_section->output_section->vma
1803                    + input_section->output_offset
1804                    + (int_rel.r_vaddr - input_section->vma)
1805                    + adjust)
1806                   & 0xf0000000)))
1807         r = bfd_reloc_overflow;
1808
1809       if (r != bfd_reloc_ok)
1810         {
1811           switch (r)
1812             {
1813             default:
1814             case bfd_reloc_outofrange:
1815               abort ();
1816             case bfd_reloc_overflow:
1817               {
1818                 const char *name;
1819
1820                 if (int_rel.r_extern)
1821                   name = h->root.root.string;
1822                 else
1823                   name = bfd_section_name (input_bfd, s);
1824                 if (! ((*info->callbacks->reloc_overflow)
1825                        (info, name, howto->name, (bfd_vma) 0,
1826                         input_bfd, input_section,
1827                         int_rel.r_vaddr - input_section->vma)))
1828                   return FALSE;
1829               }
1830               break;
1831             }
1832         }
1833     }
1834
1835   return TRUE;
1836 }
1837 \f
1838 /* Read in the relocs for a section.  */
1839
1840 static bfd_boolean
1841 mips_read_relocs (abfd, sec)
1842      bfd *abfd;
1843      asection *sec;
1844 {
1845   struct ecoff_section_tdata *section_tdata;
1846   bfd_size_type amt;
1847
1848   section_tdata = ecoff_section_data (abfd, sec);
1849   if (section_tdata == (struct ecoff_section_tdata *) NULL)
1850     {
1851       amt = sizeof (struct ecoff_section_tdata);
1852       sec->used_by_bfd = (PTR) bfd_alloc (abfd, amt);
1853       if (sec->used_by_bfd == NULL)
1854         return FALSE;
1855
1856       section_tdata = ecoff_section_data (abfd, sec);
1857       section_tdata->external_relocs = NULL;
1858       section_tdata->contents = NULL;
1859       section_tdata->offsets = NULL;
1860     }
1861
1862   if (section_tdata->external_relocs == NULL)
1863     {
1864       amt = ecoff_backend (abfd)->external_reloc_size;
1865       amt *= sec->reloc_count;
1866       section_tdata->external_relocs = (PTR) bfd_alloc (abfd, amt);
1867       if (section_tdata->external_relocs == NULL && amt != 0)
1868         return FALSE;
1869
1870       if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1871           || bfd_bread (section_tdata->external_relocs, amt, abfd) != amt)
1872         return FALSE;
1873     }
1874
1875   return TRUE;
1876 }
1877
1878 /* Relax a section when linking a MIPS ECOFF file.  This is used for
1879    embedded PIC code, which always uses PC relative branches which
1880    only have an 18 bit range on MIPS.  If a branch is not in range, we
1881    generate a long instruction sequence to compensate.  Each time we
1882    find a branch to expand, we have to check all the others again to
1883    make sure they are still in range.  This is slow, but it only has
1884    to be done when -relax is passed to the linker.
1885
1886    This routine figures out which branches need to expand; the actual
1887    expansion is done in mips_relocate_section when the section
1888    contents are relocated.  The information is stored in the offsets
1889    field of the ecoff_section_tdata structure.  An offset of 1 means
1890    that the branch must be expanded into a multi-instruction PC
1891    relative branch (such an offset will only occur for a PC relative
1892    branch to an external symbol).  Any other offset must be a multiple
1893    of four, and is the amount to change the branch by (such an offset
1894    will only occur for a PC relative branch within the same section).
1895
1896    We do not modify the section relocs or contents themselves so that
1897    if memory usage becomes an issue we can discard them and read them
1898    again.  The only information we must save in memory between this
1899    routine and the mips_relocate_section routine is the table of
1900    offsets.  */
1901
1902 static bfd_boolean
1903 mips_relax_section (abfd, sec, info, again)
1904      bfd *abfd;
1905      asection *sec;
1906      struct bfd_link_info *info;
1907      bfd_boolean *again;
1908 {
1909   struct ecoff_section_tdata *section_tdata;
1910   bfd_byte *contents = NULL;
1911   long *offsets;
1912   struct external_reloc *ext_rel;
1913   struct external_reloc *ext_rel_end;
1914   unsigned int i;
1915
1916   /* Assume we are not going to need another pass.  */
1917   *again = FALSE;
1918
1919   /* If we are not generating an ECOFF file, this is much too
1920      confusing to deal with.  */
1921   if (info->hash->creator->flavour != bfd_get_flavour (abfd))
1922     return TRUE;
1923
1924   /* If there are no relocs, there is nothing to do.  */
1925   if (sec->reloc_count == 0)
1926     return TRUE;
1927
1928   /* We are only interested in PC relative relocs, and why would there
1929      ever be one from anything but the .text section?  */
1930   if (strcmp (bfd_get_section_name (abfd, sec), ".text") != 0)
1931     return TRUE;
1932
1933   /* Read in the relocs, if we haven't already got them.  */
1934   section_tdata = ecoff_section_data (abfd, sec);
1935   if (section_tdata == (struct ecoff_section_tdata *) NULL
1936       || section_tdata->external_relocs == NULL)
1937     {
1938       if (! mips_read_relocs (abfd, sec))
1939         goto error_return;
1940       section_tdata = ecoff_section_data (abfd, sec);
1941     }
1942
1943   if (sec->_cooked_size == 0)
1944     {
1945       /* We must initialize _cooked_size only the first time we are
1946          called.  */
1947       sec->_cooked_size = sec->_raw_size;
1948     }
1949
1950   contents = section_tdata->contents;
1951   offsets = section_tdata->offsets;
1952
1953   /* Look for any external PC relative relocs.  Internal PC relative
1954      relocs are already correct in the object file, so they certainly
1955      can not overflow.  */
1956   ext_rel = (struct external_reloc *) section_tdata->external_relocs;
1957   ext_rel_end = ext_rel + sec->reloc_count;
1958   for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1959     {
1960       struct internal_reloc int_rel;
1961       struct ecoff_link_hash_entry *h;
1962       asection *hsec;
1963       bfd_signed_vma relocation;
1964       struct external_reloc *adj_ext_rel;
1965       unsigned int adj_i;
1966       unsigned long ext_count;
1967       struct ecoff_link_hash_entry **adj_h_ptr;
1968       struct ecoff_link_hash_entry **adj_h_ptr_end;
1969       struct ecoff_value_adjust *adjust;
1970       bfd_size_type amt;
1971
1972       /* If we have already expanded this reloc, we certainly don't
1973          need to do it again.  */
1974       if (offsets != (long *) NULL && offsets[i] == 1)
1975         continue;
1976
1977       /* Quickly check that this reloc is external PCREL16.  */
1978       if (bfd_header_big_endian (abfd))
1979         {
1980           if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_BIG) == 0
1981               || (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_BIG)
1982                    >> RELOC_BITS3_TYPE_SH_BIG)
1983                   != MIPS_R_PCREL16))
1984             continue;
1985         }
1986       else
1987         {
1988           if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) == 0
1989               || (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
1990                    >> RELOC_BITS3_TYPE_SH_LITTLE)
1991                   != MIPS_R_PCREL16))
1992             continue;
1993         }
1994
1995       mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
1996
1997       h = ecoff_data (abfd)->sym_hashes[int_rel.r_symndx];
1998       if (h == (struct ecoff_link_hash_entry *) NULL)
1999         abort ();
2000
2001       if (h->root.type != bfd_link_hash_defined
2002           && h->root.type != bfd_link_hash_defweak)
2003         {
2004           /* Just ignore undefined symbols.  These will presumably
2005              generate an error later in the link.  */
2006           continue;
2007         }
2008
2009       /* Get the value of the symbol.  */
2010       hsec = h->root.u.def.section;
2011       relocation = (h->root.u.def.value
2012                     + hsec->output_section->vma
2013                     + hsec->output_offset);
2014
2015       /* Subtract out the current address.  */
2016       relocation -= (sec->output_section->vma
2017                      + sec->output_offset
2018                      + (int_rel.r_vaddr - sec->vma));
2019
2020       /* The addend is stored in the object file.  In the normal case
2021          of ``bal symbol'', the addend will be -4.  It will only be
2022          different in the case of ``bal symbol+constant''.  To avoid
2023          always reading in the section contents, we don't check the
2024          addend in the object file (we could easily check the contents
2025          if we happen to have already read them in, but I fear that
2026          this could be confusing).  This means we will screw up if
2027          there is a branch to a symbol that is in range, but added to
2028          a constant which puts it out of range; in such a case the
2029          link will fail with a reloc overflow error.  Since the
2030          compiler will never generate such code, it should be easy
2031          enough to work around it by changing the assembly code in the
2032          source file.  */
2033       relocation -= 4;
2034
2035       /* Now RELOCATION is the number we want to put in the object
2036          file.  See whether it fits.  */
2037       if (relocation >= -0x20000 && relocation < 0x20000)
2038         continue;
2039
2040       /* Now that we know this reloc needs work, which will rarely
2041          happen, go ahead and grab the section contents.  */
2042       if (contents == (bfd_byte *) NULL)
2043         {
2044           if (info->keep_memory)
2045             contents = (bfd_byte *) bfd_alloc (abfd, sec->_raw_size);
2046           else
2047             contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2048           if (contents == (bfd_byte *) NULL)
2049             goto error_return;
2050           if (! bfd_get_section_contents (abfd, sec, (PTR) contents,
2051                                           (file_ptr) 0, sec->_raw_size))
2052             goto error_return;
2053           if (info->keep_memory)
2054             section_tdata->contents = contents;
2055         }
2056
2057       /* We only support changing the bal instruction.  It would be
2058          possible to handle other PC relative branches, but some of
2059          them (the conditional branches) would require a different
2060          length instruction sequence which would complicate both this
2061          routine and mips_relax_pcrel16.  It could be written if
2062          somebody felt it were important.  Ignoring this reloc will
2063          presumably cause a reloc overflow error later on.  */
2064       if (bfd_get_32 (abfd, contents + int_rel.r_vaddr - sec->vma)
2065           != 0x0411ffff) /* bgezal $0,. == bal .  */
2066         continue;
2067
2068       /* Bother.  We need to expand this reloc, and we will need to
2069          make another relaxation pass since this change may put other
2070          relocs out of range.  We need to examine the local branches
2071          and we need to allocate memory to hold the offsets we must
2072          add to them.  We also need to adjust the values of all
2073          symbols in the object file following this location.  */
2074
2075       sec->_cooked_size += PCREL16_EXPANSION_ADJUSTMENT;
2076       *again = TRUE;
2077
2078       if (offsets == (long *) NULL)
2079         {
2080           bfd_size_type size;
2081
2082           size = (bfd_size_type) sec->reloc_count * sizeof (long);
2083           offsets = (long *) bfd_zalloc (abfd, size);
2084           if (offsets == (long *) NULL)
2085             goto error_return;
2086           section_tdata->offsets = offsets;
2087         }
2088
2089       offsets[i] = 1;
2090
2091       /* Now look for all PC relative references that cross this reloc
2092          and adjust their offsets.  */
2093       adj_ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2094       for (adj_i = 0; adj_ext_rel < ext_rel_end; adj_ext_rel++, adj_i++)
2095         {
2096           struct internal_reloc adj_int_rel;
2097           bfd_vma start, stop;
2098           int change;
2099
2100           mips_ecoff_swap_reloc_in (abfd, (PTR) adj_ext_rel, &adj_int_rel);
2101
2102           if (adj_int_rel.r_type == MIPS_R_PCREL16)
2103             {
2104               unsigned long insn;
2105
2106               /* We only care about local references.  External ones
2107                  will be relocated correctly anyhow.  */
2108               if (adj_int_rel.r_extern)
2109                 continue;
2110
2111               /* We are only interested in a PC relative reloc within
2112                  this section.  FIXME: Cross section PC relative
2113                  relocs may not be handled correctly; does anybody
2114                  care?  */
2115               if (adj_int_rel.r_symndx != RELOC_SECTION_TEXT)
2116                 continue;
2117
2118               start = adj_int_rel.r_vaddr;
2119
2120               insn = bfd_get_32 (abfd,
2121                                  contents + adj_int_rel.r_vaddr - sec->vma);
2122
2123               stop = (insn & 0xffff) << 2;
2124               if ((stop & 0x20000) != 0)
2125                 stop -= 0x40000;
2126               stop += adj_int_rel.r_vaddr + 4;
2127             }
2128           else if (adj_int_rel.r_type == MIPS_R_RELHI)
2129             {
2130               struct internal_reloc rello;
2131               long addhi, addlo;
2132
2133               /* The next reloc must be MIPS_R_RELLO, and we handle
2134                  them together.  */
2135               BFD_ASSERT (adj_ext_rel + 1 < ext_rel_end);
2136
2137               mips_ecoff_swap_reloc_in (abfd, (PTR) (adj_ext_rel + 1), &rello);
2138
2139               BFD_ASSERT (rello.r_type == MIPS_R_RELLO);
2140
2141               addhi = bfd_get_32 (abfd,
2142                                    contents + adj_int_rel.r_vaddr - sec->vma);
2143               addhi &= 0xffff;
2144               if (addhi & 0x8000)
2145                 addhi -= 0x10000;
2146               addhi <<= 16;
2147
2148               addlo = bfd_get_32 (abfd, contents + rello.r_vaddr - sec->vma);
2149               addlo &= 0xffff;
2150               if (addlo & 0x8000)
2151                 addlo -= 0x10000;
2152
2153               if (adj_int_rel.r_extern)
2154                 {
2155                   /* The value we want here is
2156                        sym - RELLOaddr + addend
2157                      which we can express as
2158                        sym - (RELLOaddr - addend)
2159                      Therefore if we are expanding the area between
2160                      RELLOaddr and RELLOaddr - addend we must adjust
2161                      the addend.  This is admittedly ambiguous, since
2162                      we might mean (sym + addend) - RELLOaddr, but in
2163                      practice we don't, and there is no way to handle
2164                      that case correctly since at this point we have
2165                      no idea whether any reloc is being expanded
2166                      between sym and sym + addend.  */
2167                   start = rello.r_vaddr - (addhi + addlo);
2168                   stop = rello.r_vaddr;
2169                 }
2170               else
2171                 {
2172                   /* An internal RELHI/RELLO pair represents the
2173                      difference between two addresses, $LC0 - foo.
2174                      The symndx value is actually the difference
2175                      between the reloc address and $LC0.  This lets us
2176                      compute $LC0, and, by considering the addend,
2177                      foo.  If the reloc we are expanding falls between
2178                      those two relocs, we must adjust the addend.  At
2179                      this point, the symndx value is actually in the
2180                      r_offset field, where it was put by
2181                      mips_ecoff_swap_reloc_in.  */
2182                   start = rello.r_vaddr - adj_int_rel.r_offset;
2183                   stop = start + addhi + addlo;
2184                 }
2185             }
2186           else if (adj_int_rel.r_type == MIPS_R_SWITCH)
2187             {
2188               /* A MIPS_R_SWITCH reloc represents a word of the form
2189                    .word $L3-$LS12
2190                  The value in the object file is correct, assuming the
2191                  original value of $L3.  The symndx value is actually
2192                  the difference between the reloc address and $LS12.
2193                  This lets us compute the original value of $LS12 as
2194                    vaddr - symndx
2195                  and the original value of $L3 as
2196                    vaddr - symndx + addend
2197                  where addend is the value from the object file.  At
2198                  this point, the symndx value is actually found in the
2199                  r_offset field, since it was moved by
2200                  mips_ecoff_swap_reloc_in.  */
2201               start = adj_int_rel.r_vaddr - adj_int_rel.r_offset;
2202               stop = start + bfd_get_32 (abfd,
2203                                          (contents
2204                                           + adj_int_rel.r_vaddr
2205                                           - sec->vma));
2206             }
2207           else
2208             continue;
2209
2210           /* If the range expressed by this reloc, which is the
2211              distance between START and STOP crosses the reloc we are
2212              expanding, we must adjust the offset.  The sign of the
2213              adjustment depends upon the direction in which the range
2214              crosses the reloc being expanded.  */
2215           if (start <= int_rel.r_vaddr && stop > int_rel.r_vaddr)
2216             change = PCREL16_EXPANSION_ADJUSTMENT;
2217           else if (start > int_rel.r_vaddr && stop <= int_rel.r_vaddr)
2218             change = - PCREL16_EXPANSION_ADJUSTMENT;
2219           else
2220             change = 0;
2221
2222           offsets[adj_i] += change;
2223
2224           if (adj_int_rel.r_type == MIPS_R_RELHI)
2225             {
2226               adj_ext_rel++;
2227               adj_i++;
2228               offsets[adj_i] += change;
2229             }
2230         }
2231
2232       /* Find all symbols in this section defined by this object file
2233          and adjust their values.  Note that we decide whether to
2234          adjust the value based on the value stored in the ECOFF EXTR
2235          structure, because the value stored in the hash table may
2236          have been changed by an earlier expanded reloc and thus may
2237          no longer correctly indicate whether the symbol is before or
2238          after the expanded reloc.  */
2239       ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
2240       adj_h_ptr = ecoff_data (abfd)->sym_hashes;
2241       adj_h_ptr_end = adj_h_ptr + ext_count;
2242       for (; adj_h_ptr < adj_h_ptr_end; adj_h_ptr++)
2243         {
2244           struct ecoff_link_hash_entry *adj_h;
2245
2246           adj_h = *adj_h_ptr;
2247           if (adj_h != (struct ecoff_link_hash_entry *) NULL
2248               && (adj_h->root.type == bfd_link_hash_defined
2249                   || adj_h->root.type == bfd_link_hash_defweak)
2250               && adj_h->root.u.def.section == sec
2251               && adj_h->esym.asym.value > int_rel.r_vaddr)
2252             adj_h->root.u.def.value += PCREL16_EXPANSION_ADJUSTMENT;
2253         }
2254
2255       /* Add an entry to the symbol value adjust list.  This is used
2256          by bfd_ecoff_debug_accumulate to adjust the values of
2257          internal symbols and FDR's.  */
2258       amt = sizeof (struct ecoff_value_adjust);
2259       adjust = (struct ecoff_value_adjust *) bfd_alloc (abfd, amt);
2260       if (adjust == (struct ecoff_value_adjust *) NULL)
2261         goto error_return;
2262
2263       adjust->start = int_rel.r_vaddr;
2264       adjust->end = sec->vma + sec->_raw_size;
2265       adjust->adjust = PCREL16_EXPANSION_ADJUSTMENT;
2266
2267       adjust->next = ecoff_data (abfd)->debug_info.adjust;
2268       ecoff_data (abfd)->debug_info.adjust = adjust;
2269     }
2270
2271   if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2272     free (contents);
2273
2274   return TRUE;
2275
2276  error_return:
2277   if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2278     free (contents);
2279   return FALSE;
2280 }
2281
2282 /* This routine is called from mips_relocate_section when a PC
2283    relative reloc must be expanded into the five instruction sequence.
2284    It handles all the details of the expansion, including resolving
2285    the reloc.  */
2286
2287 static bfd_boolean
2288 mips_relax_pcrel16 (info, input_bfd, input_section, h, location, address)
2289      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2290      bfd *input_bfd;
2291      asection *input_section ATTRIBUTE_UNUSED;
2292      struct ecoff_link_hash_entry *h;
2293      bfd_byte *location;
2294      bfd_vma address;
2295 {
2296   bfd_vma relocation;
2297
2298   /* 0x0411ffff is bgezal $0,. == bal .  */
2299   BFD_ASSERT (bfd_get_32 (input_bfd, location) == 0x0411ffff);
2300
2301   /* We need to compute the distance between the symbol and the
2302      current address plus eight.  */
2303   relocation = (h->root.u.def.value
2304                 + h->root.u.def.section->output_section->vma
2305                 + h->root.u.def.section->output_offset);
2306   relocation -= address + 8;
2307
2308   /* If the lower half is negative, increment the upper 16 half.  */
2309   if ((relocation & 0x8000) != 0)
2310     relocation += 0x10000;
2311
2312   bfd_put_32 (input_bfd, (bfd_vma) 0x04110001, location); /* bal .+8 */
2313   bfd_put_32 (input_bfd,
2314               0x3c010000 | ((relocation >> 16) & 0xffff), /* lui $at,XX */
2315               location + 4);
2316   bfd_put_32 (input_bfd,
2317               0x24210000 | (relocation & 0xffff), /* addiu $at,$at,XX */
2318               location + 8);
2319   bfd_put_32 (input_bfd,
2320               (bfd_vma) 0x003f0821, location + 12); /* addu $at,$at,$ra */
2321   bfd_put_32 (input_bfd,
2322               (bfd_vma) 0x0020f809, location + 16); /* jalr $at */
2323
2324   return TRUE;
2325 }
2326
2327 /* Given a .sdata section and a .rel.sdata in-memory section, store
2328    relocation information into the .rel.sdata section which can be
2329    used at runtime to relocate the section.  This is called by the
2330    linker when the --embedded-relocs switch is used.  This is called
2331    after the add_symbols entry point has been called for all the
2332    objects, and before the final_link entry point is called.  This
2333    function presumes that the object was compiled using
2334    -membedded-pic.  */
2335
2336 bfd_boolean
2337 bfd_mips_ecoff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2338      bfd *abfd;
2339      struct bfd_link_info *info;
2340      asection *datasec;
2341      asection *relsec;
2342      char **errmsg;
2343 {
2344   struct ecoff_link_hash_entry **sym_hashes;
2345   struct ecoff_section_tdata *section_tdata;
2346   struct external_reloc *ext_rel;
2347   struct external_reloc *ext_rel_end;
2348   bfd_byte *p;
2349   bfd_size_type amt;
2350
2351   BFD_ASSERT (! info->relocatable);
2352
2353   *errmsg = NULL;
2354
2355   if (datasec->reloc_count == 0)
2356     return TRUE;
2357
2358   sym_hashes = ecoff_data (abfd)->sym_hashes;
2359
2360   if (! mips_read_relocs (abfd, datasec))
2361     return FALSE;
2362
2363   amt = (bfd_size_type) datasec->reloc_count * 4;
2364   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2365   if (relsec->contents == NULL)
2366     return FALSE;
2367
2368   p = relsec->contents;
2369
2370   section_tdata = ecoff_section_data (abfd, datasec);
2371   ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2372   ext_rel_end = ext_rel + datasec->reloc_count;
2373   for (; ext_rel < ext_rel_end; ext_rel++, p += 4)
2374     {
2375       struct internal_reloc int_rel;
2376       bfd_boolean text_relative;
2377
2378       mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2379
2380       /* We are going to write a four byte word into the runtime reloc
2381          section.  The word will be the address in the data section
2382          which must be relocated.  This must be on a word boundary,
2383          which means the lower two bits must be zero.  We use the
2384          least significant bit to indicate how the value in the data
2385          section must be relocated.  A 0 means that the value is
2386          relative to the text section, while a 1 indicates that the
2387          value is relative to the data section.  Given that we are
2388          assuming the code was compiled using -membedded-pic, there
2389          should not be any other possibilities.  */
2390
2391       /* We can only relocate REFWORD relocs at run time.  */
2392       if (int_rel.r_type != MIPS_R_REFWORD)
2393         {
2394           *errmsg = _("unsupported reloc type");
2395           bfd_set_error (bfd_error_bad_value);
2396           return FALSE;
2397         }
2398
2399       if (int_rel.r_extern)
2400         {
2401           struct ecoff_link_hash_entry *h;
2402
2403           h = sym_hashes[int_rel.r_symndx];
2404           /* If h is NULL, that means that there is a reloc against an
2405              external symbol which we thought was just a debugging
2406              symbol.  This should not happen.  */
2407           if (h == (struct ecoff_link_hash_entry *) NULL)
2408             abort ();
2409           if ((h->root.type == bfd_link_hash_defined
2410                || h->root.type == bfd_link_hash_defweak)
2411               && (h->root.u.def.section->flags & SEC_CODE) != 0)
2412             text_relative = TRUE;
2413           else
2414             text_relative = FALSE;
2415         }
2416       else
2417         {
2418           switch (int_rel.r_symndx)
2419             {
2420             case RELOC_SECTION_TEXT:
2421               text_relative = TRUE;
2422               break;
2423             case RELOC_SECTION_SDATA:
2424             case RELOC_SECTION_SBSS:
2425             case RELOC_SECTION_LIT8:
2426               text_relative = FALSE;
2427               break;
2428             default:
2429               /* No other sections should appear in -membedded-pic
2430                  code.  */
2431               *errmsg = _("reloc against unsupported section");
2432               bfd_set_error (bfd_error_bad_value);
2433               return FALSE;
2434             }
2435         }
2436
2437       if ((int_rel.r_offset & 3) != 0)
2438         {
2439           *errmsg = _("reloc not properly aligned");
2440           bfd_set_error (bfd_error_bad_value);
2441           return FALSE;
2442         }
2443
2444       bfd_put_32 (abfd,
2445                   (int_rel.r_vaddr - datasec->vma + datasec->output_offset
2446                    + (text_relative ? 0 : 1)),
2447                   p);
2448     }
2449
2450   return TRUE;
2451 }
2452 \f
2453 /* This is the ECOFF backend structure.  The backend field of the
2454    target vector points to this.  */
2455
2456 static const struct ecoff_backend_data mips_ecoff_backend_data =
2457 {
2458   /* COFF backend structure.  */
2459   {
2460     (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2461     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2462     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2463     (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2464     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2465     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2466     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2467     mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
2468     mips_ecoff_swap_scnhdr_out,
2469     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
2470     mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
2471     mips_ecoff_swap_scnhdr_in, NULL,
2472     mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2473     _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2474     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2475     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2476     NULL, NULL
2477   },
2478   /* Supported architecture.  */
2479   bfd_arch_mips,
2480   /* Initial portion of armap string.  */
2481   "__________",
2482   /* The page boundary used to align sections in a demand-paged
2483      executable file.  E.g., 0x1000.  */
2484   0x1000,
2485   /* TRUE if the .rdata section is part of the text segment, as on the
2486      Alpha.  FALSE if .rdata is part of the data segment, as on the
2487      MIPS.  */
2488   FALSE,
2489   /* Bitsize of constructor entries.  */
2490   32,
2491   /* Reloc to use for constructor entries.  */
2492   &mips_howto_table[MIPS_R_REFWORD],
2493   {
2494     /* Symbol table magic number.  */
2495     magicSym,
2496     /* Alignment of debugging information.  E.g., 4.  */
2497     4,
2498     /* Sizes of external symbolic information.  */
2499     sizeof (struct hdr_ext),
2500     sizeof (struct dnr_ext),
2501     sizeof (struct pdr_ext),
2502     sizeof (struct sym_ext),
2503     sizeof (struct opt_ext),
2504     sizeof (struct fdr_ext),
2505     sizeof (struct rfd_ext),
2506     sizeof (struct ext_ext),
2507     /* Functions to swap in external symbolic data.  */
2508     ecoff_swap_hdr_in,
2509     ecoff_swap_dnr_in,
2510     ecoff_swap_pdr_in,
2511     ecoff_swap_sym_in,
2512     ecoff_swap_opt_in,
2513     ecoff_swap_fdr_in,
2514     ecoff_swap_rfd_in,
2515     ecoff_swap_ext_in,
2516     _bfd_ecoff_swap_tir_in,
2517     _bfd_ecoff_swap_rndx_in,
2518     /* Functions to swap out external symbolic data.  */
2519     ecoff_swap_hdr_out,
2520     ecoff_swap_dnr_out,
2521     ecoff_swap_pdr_out,
2522     ecoff_swap_sym_out,
2523     ecoff_swap_opt_out,
2524     ecoff_swap_fdr_out,
2525     ecoff_swap_rfd_out,
2526     ecoff_swap_ext_out,
2527     _bfd_ecoff_swap_tir_out,
2528     _bfd_ecoff_swap_rndx_out,
2529     /* Function to read in symbolic data.  */
2530     _bfd_ecoff_slurp_symbolic_info
2531   },
2532   /* External reloc size.  */
2533   RELSZ,
2534   /* Reloc swapping functions.  */
2535   mips_ecoff_swap_reloc_in,
2536   mips_ecoff_swap_reloc_out,
2537   /* Backend reloc tweaking.  */
2538   mips_adjust_reloc_in,
2539   mips_adjust_reloc_out,
2540   /* Relocate section contents while linking.  */
2541   mips_relocate_section,
2542   /* Do final adjustments to filehdr and aouthdr.  */
2543   NULL,
2544   /* Read an element from an archive at a given file position.  */
2545   _bfd_get_elt_at_filepos
2546 };
2547
2548 /* Looking up a reloc type is MIPS specific.  */
2549 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
2550
2551 /* Getting relocated section contents is generic.  */
2552 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2553   bfd_generic_get_relocated_section_contents
2554
2555 /* Handling file windows is generic.  */
2556 #define _bfd_ecoff_get_section_contents_in_window \
2557   _bfd_generic_get_section_contents_in_window
2558
2559 /* Relaxing sections is MIPS specific.  */
2560 #define _bfd_ecoff_bfd_relax_section mips_relax_section
2561
2562 /* GC of sections is not done.  */
2563 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2564
2565 /* Merging of sections is not done.  */
2566 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2567
2568 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2569
2570 extern const bfd_target ecoff_big_vec;
2571
2572 const bfd_target ecoff_little_vec =
2573 {
2574   "ecoff-littlemips",           /* name */
2575   bfd_target_ecoff_flavour,
2576   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2577   BFD_ENDIAN_LITTLE,            /* header byte order is little */
2578
2579   (HAS_RELOC | EXEC_P |         /* object flags */
2580    HAS_LINENO | HAS_DEBUG |
2581    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2582
2583   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2584   0,                            /* leading underscore */
2585   ' ',                          /* ar_pad_char */
2586   15,                           /* ar_max_namelen */
2587   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2588      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2589      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2590   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2591      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2592      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2593
2594   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2595      _bfd_ecoff_archive_p, _bfd_dummy_target},
2596   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2597      _bfd_generic_mkarchive, bfd_false},
2598   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2599      _bfd_write_archive_contents, bfd_false},
2600
2601      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2602      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2603      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2604      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2605      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2606      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2607      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2608      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2609      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2610
2611   & ecoff_big_vec,
2612
2613   (PTR) &mips_ecoff_backend_data
2614 };
2615
2616 const bfd_target ecoff_big_vec =
2617 {
2618   "ecoff-bigmips",              /* name */
2619   bfd_target_ecoff_flavour,
2620   BFD_ENDIAN_BIG,               /* data byte order is big */
2621   BFD_ENDIAN_BIG,               /* header byte order is big */
2622
2623   (HAS_RELOC | EXEC_P |         /* object flags */
2624    HAS_LINENO | HAS_DEBUG |
2625    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2626
2627   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2628   0,                            /* leading underscore */
2629   ' ',                          /* ar_pad_char */
2630   15,                           /* ar_max_namelen */
2631   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2632      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2633      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2634   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2635      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2636      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2637  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2638     _bfd_ecoff_archive_p, _bfd_dummy_target},
2639  {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2640     _bfd_generic_mkarchive, bfd_false},
2641  {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2642     _bfd_write_archive_contents, bfd_false},
2643
2644      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2645      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2646      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2647      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2648      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2649      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2650      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2651      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2652      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2653
2654   & ecoff_little_vec,
2655
2656   (PTR) &mips_ecoff_backend_data
2657 };
2658
2659 const bfd_target ecoff_biglittle_vec =
2660 {
2661   "ecoff-biglittlemips",                /* name */
2662   bfd_target_ecoff_flavour,
2663   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2664   BFD_ENDIAN_BIG,               /* header byte order is big */
2665
2666   (HAS_RELOC | EXEC_P |         /* object flags */
2667    HAS_LINENO | HAS_DEBUG |
2668    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2669
2670   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2671   0,                            /* leading underscore */
2672   ' ',                          /* ar_pad_char */
2673   15,                           /* ar_max_namelen */
2674   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2675      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2676      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2677   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2678      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2679      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2680
2681   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2682      _bfd_ecoff_archive_p, _bfd_dummy_target},
2683   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2684      _bfd_generic_mkarchive, bfd_false},
2685   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2686      _bfd_write_archive_contents, bfd_false},
2687
2688      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2689      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2690      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2691      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2692      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2693      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2694      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2695      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2696      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2697
2698   NULL,
2699
2700   (PTR) &mips_ecoff_backend_data
2701 };