bfd/coff-mips.c

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