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