bfd/coff-mips.c

   1 /* BFD back-end for MIPS Extended-Coff files.
   2    Copyright (C) 1990-2016 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "coff/internal.h"
  28 #include "coff/sym.h"
  29 #include "coff/symconst.h"
  30 #include "coff/ecoff.h"
  31 #include "coff/mips.h"
  32 #include "libcoff.h"
  33 #include "libecoff.h"
  34 \f
  35 /* Prototypes for static functions.  */
  36 static bfd_reloc_status_type
  37 mips_generic_reloc
  38   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  39 static bfd_reloc_status_type
  40 mips_refhi_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type
  43 mips_reflo_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type
  46 mips_gprel_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48
  49 \f
  50 /* ECOFF has COFF sections, but the debugging information is stored in
  51    a completely different format.  ECOFF targets use some of the
  52    swapping routines from coffswap.h, and some of the generic COFF
  53    routines in coffgen.c, but, unlike the real COFF targets, do not
  54    use coffcode.h itself.
  55
  56    Get the generic COFF swapping routines, except for the reloc,
  57    symbol, and lineno ones.  Give them ECOFF names.  */
  58 #define MIPSECOFF
  59 #define NO_COFF_RELOCS
  60 #define NO_COFF_SYMBOLS
  61 #define NO_COFF_LINENOS
  62 #define coff_swap_filehdr_in  mips_ecoff_swap_filehdr_in
  63 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
  64 #define coff_swap_aouthdr_in  mips_ecoff_swap_aouthdr_in
  65 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
  66 #define coff_swap_scnhdr_in   mips_ecoff_swap_scnhdr_in
  67 #define coff_swap_scnhdr_out  mips_ecoff_swap_scnhdr_out
  68
  69 #include "coffswap.h"
  70
  71 /* Get the ECOFF swapping routines.  */
  72 #define ECOFF_32
  73 #include "ecoffswap.h"
  74 \f
  75 /* How to process the various relocs types.  */
  76
  77 static reloc_howto_type mips_howto_table[] =
  78 {
  79   /* Reloc type 0 is ignored.  The reloc reading code ensures that
  80      this is a reference to the .abs section, which will cause
  81      bfd_perform_relocation to do nothing.  */
  82   HOWTO (MIPS_R_IGNORE, /* type */
  83          0,                     /* rightshift */
  84          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  85          8,                     /* bitsize */
  86          FALSE,                 /* pc_relative */
  87          0,                     /* bitpos */
  88          complain_overflow_dont, /* complain_on_overflow */
  89          0,                     /* special_function */
  90          "IGNORE",              /* name */
  91          FALSE,                 /* partial_inplace */
  92          0,                     /* src_mask */
  93          0,                     /* dst_mask */
  94          FALSE),                /* pcrel_offset */
  95
  96   /* A 16 bit reference to a symbol, normally from a data section.  */
  97   HOWTO (MIPS_R_REFHALF,        /* type */
  98          0,                     /* rightshift */
  99          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 100          16,                    /* bitsize */
 101          FALSE,                 /* pc_relative */
 102          0,                     /* bitpos */
 103          complain_overflow_bitfield, /* complain_on_overflow */
 104          mips_generic_reloc,    /* special_function */
 105          "REFHALF",             /* name */
 106          TRUE,                  /* partial_inplace */
 107          0xffff,                /* src_mask */
 108          0xffff,                /* dst_mask */
 109          FALSE),                /* pcrel_offset */
 110
 111   /* A 32 bit reference to a symbol, normally from a data section.  */
 112   HOWTO (MIPS_R_REFWORD,        /* type */
 113          0,                     /* rightshift */
 114          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 115          32,                    /* bitsize */
 116          FALSE,                 /* pc_relative */
 117          0,                     /* bitpos */
 118          complain_overflow_bitfield, /* complain_on_overflow */
 119          mips_generic_reloc,    /* special_function */
 120          "REFWORD",             /* name */
 121          TRUE,                  /* partial_inplace */
 122          0xffffffff,            /* src_mask */
 123          0xffffffff,            /* dst_mask */
 124          FALSE),                /* pcrel_offset */
 125
 126   /* A 26 bit absolute jump address.  */
 127   HOWTO (MIPS_R_JMPADDR,        /* type */
 128          2,                     /* rightshift */
 129          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 130          26,                    /* bitsize */
 131          FALSE,                 /* pc_relative */
 132          0,                     /* bitpos */
 133          complain_overflow_dont, /* complain_on_overflow */
 134                                 /* This needs complex overflow
 135                                    detection, because the upper four
 136                                    bits must match the PC.  */
 137          mips_generic_reloc,    /* special_function */
 138          "JMPADDR",             /* name */
 139          TRUE,                  /* partial_inplace */
 140          0x3ffffff,             /* src_mask */
 141          0x3ffffff,             /* dst_mask */
 142          FALSE),                /* pcrel_offset */
 143
 144   /* The high 16 bits of a symbol value.  Handled by the function
 145      mips_refhi_reloc.  */
 146   HOWTO (MIPS_R_REFHI,          /* type */
 147          16,                    /* rightshift */
 148          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          16,                    /* bitsize */
 150          FALSE,                 /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_bitfield, /* complain_on_overflow */
 153          mips_refhi_reloc,      /* special_function */
 154          "REFHI",               /* name */
 155          TRUE,                  /* partial_inplace */
 156          0xffff,                /* src_mask */
 157          0xffff,                /* dst_mask */
 158          FALSE),                /* pcrel_offset */
 159
 160   /* The low 16 bits of a symbol value.  */
 161   HOWTO (MIPS_R_REFLO,          /* type */
 162          0,                     /* rightshift */
 163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          16,                    /* bitsize */
 165          FALSE,                 /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_dont, /* complain_on_overflow */
 168          mips_reflo_reloc,      /* special_function */
 169          "REFLO",               /* name */
 170          TRUE,                  /* partial_inplace */
 171          0xffff,                /* src_mask */
 172          0xffff,                /* dst_mask */
 173          FALSE),                /* pcrel_offset */
 174
 175   /* A reference to an offset from the gp register.  Handled by the
 176      function mips_gprel_reloc.  */
 177   HOWTO (MIPS_R_GPREL,          /* type */
 178          0,                     /* rightshift */
 179          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 180          16,                    /* bitsize */
 181          FALSE,                 /* pc_relative */
 182          0,                     /* bitpos */
 183          complain_overflow_signed, /* complain_on_overflow */
 184          mips_gprel_reloc,      /* special_function */
 185          "GPREL",               /* name */
 186          TRUE,                  /* partial_inplace */
 187          0xffff,                /* src_mask */
 188          0xffff,                /* dst_mask */
 189          FALSE),                /* pcrel_offset */
 190
 191   /* A reference to a literal using an offset from the gp register.
 192      Handled by the function mips_gprel_reloc.  */
 193   HOWTO (MIPS_R_LITERAL,        /* type */
 194          0,                     /* rightshift */
 195          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 196          16,                    /* bitsize */
 197          FALSE,                 /* pc_relative */
 198          0,                     /* bitpos */
 199          complain_overflow_signed, /* complain_on_overflow */
 200          mips_gprel_reloc,      /* special_function */
 201          "LITERAL",             /* name */
 202          TRUE,                  /* partial_inplace */
 203          0xffff,                /* src_mask */
 204          0xffff,                /* dst_mask */
 205          FALSE),                /* pcrel_offset */
 206
 207   EMPTY_HOWTO (8),
 208   EMPTY_HOWTO (9),
 209   EMPTY_HOWTO (10),
 210   EMPTY_HOWTO (11),
 211
 212   /* FIXME: This relocation is used (internally only) to represent branches
 213      when assembling.  It should never appear in output files, and
 214      be removed.  (It used to be used for embedded-PIC support.)  */
 215   HOWTO (MIPS_R_PCREL16,        /* type */
 216          2,                     /* rightshift */
 217          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 218          16,                    /* bitsize */
 219          TRUE,                  /* pc_relative */
 220          0,                     /* bitpos */
 221          complain_overflow_signed, /* complain_on_overflow */
 222          mips_generic_reloc,    /* special_function */
 223          "PCREL16",             /* name */
 224          TRUE,                  /* partial_inplace */
 225          0xffff,                /* src_mask */
 226          0xffff,                /* dst_mask */
 227          TRUE),                 /* pcrel_offset */
 228 };
 229
 230 #define MIPS_HOWTO_COUNT \
 231   (sizeof mips_howto_table / sizeof mips_howto_table[0])
 232 \f
 233 /* See whether the magic number matches.  */
 234
 235 static bfd_boolean
 236 mips_ecoff_bad_format_hook (bfd * abfd, void * filehdr)
 237 {
 238   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 239
 240   switch (internal_f->f_magic)
 241     {
 242     case MIPS_MAGIC_1:
 243       /* I don't know what endianness this implies.  */
 244       return TRUE;
 245
 246     case MIPS_MAGIC_BIG:
 247     case MIPS_MAGIC_BIG2:
 248     case MIPS_MAGIC_BIG3:
 249       return bfd_big_endian (abfd);
 250
 251     case MIPS_MAGIC_LITTLE:
 252     case MIPS_MAGIC_LITTLE2:
 253     case MIPS_MAGIC_LITTLE3:
 254       return bfd_little_endian (abfd);
 255
 256     default:
 257       return FALSE;
 258     }
 259 }
 260 \f
 261 /* Reloc handling.  MIPS ECOFF relocs are packed into 8 bytes in
 262    external form.  They use a bit which indicates whether the symbol
 263    is external.  */
 264
 265 /* Swap a reloc in.  */
 266
 267 static void
 268 mips_ecoff_swap_reloc_in (bfd *  abfd,
 269                           void * ext_ptr,
 270                           struct internal_reloc *intern)
 271 {
 272   const RELOC *ext = (RELOC *) ext_ptr;
 273
 274   intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
 275   if (bfd_header_big_endian (abfd))
 276     {
 277       intern->r_symndx = (((int) ext->r_bits[0]
 278                            << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
 279                           | ((int) ext->r_bits[1]
 280                              << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
 281                           | ((int) ext->r_bits[2]
 282                              << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
 283       intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
 284                         >> RELOC_BITS3_TYPE_SH_BIG);
 285       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
 286     }
 287   else
 288     {
 289       intern->r_symndx = (((int) ext->r_bits[0]
 290                            << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
 291                           | ((int) ext->r_bits[1]
 292                              << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
 293                           | ((int) ext->r_bits[2]
 294                              << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
 295       intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
 296                          >> RELOC_BITS3_TYPE_SH_LITTLE)
 297                         | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
 298                            << RELOC_BITS3_TYPEHI_SH_LITTLE));
 299       intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
 300     }
 301 }
 302
 303 /* Swap a reloc out.  */
 304
 305 static void
 306 mips_ecoff_swap_reloc_out (bfd * abfd,
 307                            const struct internal_reloc * intern,
 308                            void * dst)
 309 {
 310   RELOC *ext = (RELOC *) dst;
 311   long r_symndx;
 312
 313   BFD_ASSERT (intern->r_extern
 314               || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
 315
 316   r_symndx = intern->r_symndx;
 317
 318   H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
 319   if (bfd_header_big_endian (abfd))
 320     {
 321       ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
 322       ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
 323       ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
 324       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
 325                          & RELOC_BITS3_TYPE_BIG)
 326                         | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
 327     }
 328   else
 329     {
 330       ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
 331       ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
 332       ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
 333       ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
 334                          & RELOC_BITS3_TYPE_LITTLE)
 335                         | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
 336                             & RELOC_BITS3_TYPEHI_LITTLE))
 337                         | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
 338     }
 339 }
 340
 341 /* Finish canonicalizing a reloc.  Part of this is generic to all
 342    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 343    this backend routine.  It must fill in the howto field.  */
 344
 345 static void
 346 mips_adjust_reloc_in (bfd *abfd,
 347                       const struct internal_reloc *intern,
 348                       arelent *rptr)
 349 {
 350   if (intern->r_type > MIPS_R_PCREL16)
 351     abort ();
 352
 353   if (! intern->r_extern
 354       && (intern->r_type == MIPS_R_GPREL
 355           || intern->r_type == MIPS_R_LITERAL))
 356     rptr->addend += ecoff_data (abfd)->gp;
 357
 358   /* If the type is MIPS_R_IGNORE, make sure this is a reference to
 359      the absolute section so that the reloc is ignored.  */
 360   if (intern->r_type == MIPS_R_IGNORE)
 361     rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 362
 363   rptr->howto = &mips_howto_table[intern->r_type];
 364 }
 365
 366 /* Make any adjustments needed to a reloc before writing it out.  None
 367    are needed for MIPS.  */
 368
 369 static void
 370 mips_adjust_reloc_out (bfd *abfd ATTRIBUTE_UNUSED,
 371                        const arelent *rel ATTRIBUTE_UNUSED,
 372                        struct internal_reloc *intern ATTRIBUTE_UNUSED)
 373 {
 374 }
 375
 376 /* ECOFF relocs are either against external symbols, or against
 377    sections.  If we are producing relocatable output, and the reloc
 378    is against an external symbol, and nothing has given us any
 379    additional addend, the resulting reloc will also be against the
 380    same symbol.  In such a case, we don't want to change anything
 381    about the way the reloc is handled, since it will all be done at
 382    final link time.  Rather than put special case code into
 383    bfd_perform_relocation, all the reloc types use this howto
 384    function.  It just short circuits the reloc if producing
 385    relocatable output against an external symbol.  */
 386
 387 static bfd_reloc_status_type
 388 mips_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 389                     arelent *reloc_entry,
 390                     asymbol *symbol,
 391                     void * data ATTRIBUTE_UNUSED,
 392                     asection *input_section,
 393                     bfd *output_bfd,
 394                     char **error_message ATTRIBUTE_UNUSED)
 395 {
 396   if (output_bfd != (bfd *) NULL
 397       && (symbol->flags & BSF_SECTION_SYM) == 0
 398       && reloc_entry->addend == 0)
 399     {
 400       reloc_entry->address += input_section->output_offset;
 401       return bfd_reloc_ok;
 402     }
 403
 404   return bfd_reloc_continue;
 405 }
 406
 407 /* Do a REFHI relocation.  This has to be done in combination with a
 408    REFLO reloc, because there is a carry from the REFLO to the REFHI.
 409    Here we just save the information we need; we do the actual
 410    relocation when we see the REFLO.  MIPS ECOFF requires that the
 411    REFLO immediately follow the REFHI.  As a GNU extension, we permit
 412    an arbitrary number of HI relocs to be associated with a single LO
 413    reloc.  This extension permits gcc to output the HI and LO relocs
 414    itself.  */
 415
 416 struct mips_hi
 417 {
 418   struct mips_hi *next;
 419   bfd_byte *addr;
 420   bfd_vma addend;
 421 };
 422
 423 /* FIXME: This should not be a static variable.  */
 424
 425 static struct mips_hi *mips_refhi_list;
 426
 427 static bfd_reloc_status_type
 428 mips_refhi_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 429                   arelent *reloc_entry,
 430                   asymbol *symbol,
 431                   void * data,
 432                   asection *input_section,
 433                   bfd *output_bfd,
 434                   char **error_message ATTRIBUTE_UNUSED)
 435 {
 436   bfd_reloc_status_type ret;
 437   bfd_vma relocation;
 438   struct mips_hi *n;
 439
 440   /* If we're relocating, and this an external symbol, we don't want
 441      to change anything.  */
 442   if (output_bfd != (bfd *) NULL
 443       && (symbol->flags & BSF_SECTION_SYM) == 0
 444       && reloc_entry->addend == 0)
 445     {
 446       reloc_entry->address += input_section->output_offset;
 447       return bfd_reloc_ok;
 448     }
 449
 450   ret = bfd_reloc_ok;
 451   if (bfd_is_und_section (symbol->section)
 452       && output_bfd == (bfd *) NULL)
 453     ret = bfd_reloc_undefined;
 454
 455   if (bfd_is_com_section (symbol->section))
 456     relocation = 0;
 457   else
 458     relocation = symbol->value;
 459
 460   relocation += symbol->section->output_section->vma;
 461   relocation += symbol->section->output_offset;
 462   relocation += reloc_entry->addend;
 463
 464   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 465     return bfd_reloc_outofrange;
 466
 467   /* Save the information, and let REFLO do the actual relocation.  */
 468   n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
 469   if (n == NULL)
 470     return bfd_reloc_outofrange;
 471   n->addr = (bfd_byte *) data + reloc_entry->address;
 472   n->addend = relocation;
 473   n->next = mips_refhi_list;
 474   mips_refhi_list = n;
 475
 476   if (output_bfd != (bfd *) NULL)
 477     reloc_entry->address += input_section->output_offset;
 478
 479   return ret;
 480 }
 481
 482 /* Do a REFLO relocation.  This is a straightforward 16 bit inplace
 483    relocation; this function exists in order to do the REFHI
 484    relocation described above.  */
 485
 486 static bfd_reloc_status_type
 487 mips_reflo_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 488                   arelent *reloc_entry,
 489                   asymbol *symbol,
 490                   void * data,
 491                   asection *input_section,
 492                   bfd *output_bfd,
 493                   char **error_message ATTRIBUTE_UNUSED)
 494 {
 495   if (mips_refhi_list != NULL)
 496     {
 497       struct mips_hi *l;
 498
 499       l = mips_refhi_list;
 500       while (l != NULL)
 501         {
 502           unsigned long insn;
 503           unsigned long val;
 504           unsigned long vallo;
 505           struct mips_hi *next;
 506
 507           /* Do the REFHI relocation.  Note that we actually don't
 508              need to know anything about the REFLO itself, except
 509              where to find the low 16 bits of the addend needed by the
 510              REFHI.  */
 511           insn = bfd_get_32 (abfd, l->addr);
 512           vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
 513                    & 0xffff);
 514           val = ((insn & 0xffff) << 16) + vallo;
 515           val += l->addend;
 516
 517           /* The low order 16 bits are always treated as a signed
 518              value.  Therefore, a negative value in the low order bits
 519              requires an adjustment in the high order bits.  We need
 520              to make this adjustment in two ways: once for the bits we
 521              took from the data, and once for the bits we are putting
 522              back in to the data.  */
 523           if ((vallo & 0x8000) != 0)
 524             val -= 0x10000;
 525           if ((val & 0x8000) != 0)
 526             val += 0x10000;
 527
 528           insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
 529           bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
 530
 531           next = l->next;
 532           free (l);
 533           l = next;
 534         }
 535
 536       mips_refhi_list = NULL;
 537     }
 538
 539   /* Now do the REFLO reloc in the usual way.  */
 540   return mips_generic_reloc (abfd, reloc_entry, symbol, data,
 541                               input_section, output_bfd, error_message);
 542 }
 543
 544 /* Do a GPREL relocation.  This is a 16 bit value which must become
 545    the offset from the gp register.  */
 546
 547 static bfd_reloc_status_type
 548 mips_gprel_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 549                   arelent *reloc_entry,
 550                   asymbol *symbol,
 551                   void * data,
 552                   asection *input_section,
 553                   bfd *output_bfd,
 554                   char **error_message ATTRIBUTE_UNUSED)
 555 {
 556   bfd_boolean relocatable;
 557   bfd_vma gp;
 558   bfd_vma relocation;
 559   unsigned long val;
 560   unsigned long insn;
 561
 562   /* If we're relocating, and this is an external symbol with no
 563      addend, we don't want to change anything.  We will only have an
 564      addend if this is a newly created reloc, not read from an ECOFF
 565      file.  */
 566   if (output_bfd != (bfd *) NULL
 567       && (symbol->flags & BSF_SECTION_SYM) == 0
 568       && reloc_entry->addend == 0)
 569     {
 570       reloc_entry->address += input_section->output_offset;
 571       return bfd_reloc_ok;
 572     }
 573
 574   if (output_bfd != (bfd *) NULL)
 575     relocatable = TRUE;
 576   else
 577     {
 578       relocatable = FALSE;
 579       output_bfd = symbol->section->output_section->owner;
 580     }
 581
 582   if (bfd_is_und_section (symbol->section) && ! relocatable)
 583     return bfd_reloc_undefined;
 584
 585   /* We have to figure out the gp value, so that we can adjust the
 586      symbol value correctly.  We look up the symbol _gp in the output
 587      BFD.  If we can't find it, we're stuck.  We cache it in the ECOFF
 588      target data.  We don't need to adjust the symbol value for an
 589      external symbol if we are producing relocatable output.  */
 590   gp = _bfd_get_gp_value (output_bfd);
 591   if (gp == 0
 592       && (! relocatable
 593           || (symbol->flags & BSF_SECTION_SYM) != 0))
 594     {
 595       if (relocatable)
 596         {
 597           /* Make up a value.  */
 598           gp = symbol->section->output_section->vma + 0x4000;
 599           _bfd_set_gp_value (output_bfd, gp);
 600         }
 601       else
 602         {
 603           unsigned int count;
 604           asymbol **sym;
 605           unsigned int i;
 606
 607           count = bfd_get_symcount (output_bfd);
 608           sym = bfd_get_outsymbols (output_bfd);
 609
 610           if (sym == (asymbol **) NULL)
 611             i = count;
 612           else
 613             {
 614               for (i = 0; i < count; i++, sym++)
 615                 {
 616                   register const char *name;
 617
 618                   name = bfd_asymbol_name (*sym);
 619                   if (*name == '_' && strcmp (name, "_gp") == 0)
 620                     {
 621                       gp = bfd_asymbol_value (*sym);
 622                       _bfd_set_gp_value (output_bfd, gp);
 623                       break;
 624                     }
 625                 }
 626             }
 627
 628           if (i >= count)
 629             {
 630               /* Only get the error once.  */
 631               gp = 4;
 632               _bfd_set_gp_value (output_bfd, gp);
 633               *error_message =
 634                 (char *) _("GP relative relocation when _gp not defined");
 635               return bfd_reloc_dangerous;
 636             }
 637         }
 638     }
 639
 640   if (bfd_is_com_section (symbol->section))
 641     relocation = 0;
 642   else
 643     relocation = symbol->value;
 644
 645   relocation += symbol->section->output_section->vma;
 646   relocation += symbol->section->output_offset;
 647
 648   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 649     return bfd_reloc_outofrange;
 650
 651   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 652
 653   /* Set val to the offset into the section or symbol.  */
 654   val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
 655   if (val & 0x8000)
 656     val -= 0x10000;
 657
 658   /* Adjust val for the final section location and GP value.  If we
 659      are producing relocatable output, we don't want to do this for
 660      an external symbol.  */
 661   if (! relocatable
 662       || (symbol->flags & BSF_SECTION_SYM) != 0)
 663     val += relocation - gp;
 664
 665   insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
 666   bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
 667
 668   if (relocatable)
 669     reloc_entry->address += input_section->output_offset;
 670
 671   /* Make sure it fit in 16 bits.  */
 672   if ((long) val >= 0x8000 || (long) val < -0x8000)
 673     return bfd_reloc_overflow;
 674
 675   return bfd_reloc_ok;
 676 }
 677
 678 /* Get the howto structure for a generic reloc type.  */
 679
 680 static reloc_howto_type *
 681 mips_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 682                             bfd_reloc_code_real_type code)
 683 {
 684   int mips_type;
 685
 686   switch (code)
 687     {
 688     case BFD_RELOC_16:
 689       mips_type = MIPS_R_REFHALF;
 690       break;
 691     case BFD_RELOC_32:
 692     case BFD_RELOC_CTOR:
 693       mips_type = MIPS_R_REFWORD;
 694       break;
 695     case BFD_RELOC_MIPS_JMP:
 696       mips_type = MIPS_R_JMPADDR;
 697       break;
 698     case BFD_RELOC_HI16_S:
 699       mips_type = MIPS_R_REFHI;
 700       break;
 701     case BFD_RELOC_LO16:
 702       mips_type = MIPS_R_REFLO;
 703       break;
 704     case BFD_RELOC_GPREL16:
 705       mips_type = MIPS_R_GPREL;
 706       break;
 707     case BFD_RELOC_MIPS_LITERAL:
 708       mips_type = MIPS_R_LITERAL;
 709       break;
 710     case BFD_RELOC_16_PCREL_S2:
 711       mips_type = MIPS_R_PCREL16;
 712       break;
 713     default:
 714       return (reloc_howto_type *) NULL;
 715     }
 716
 717   return &mips_howto_table[mips_type];
 718 }
 719
 720 static reloc_howto_type *
 721 mips_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 722                             const char *r_name)
 723 {
 724   unsigned int i;
 725
 726   for (i = 0;
 727        i < sizeof (mips_howto_table) / sizeof (mips_howto_table[0]);
 728        i++)
 729     if (mips_howto_table[i].name != NULL
 730         && strcasecmp (mips_howto_table[i].name, r_name) == 0)
 731       return &mips_howto_table[i];
 732
 733   return NULL;
 734 }
 735 \f
 736 /* A helper routine for mips_relocate_section which handles the REFHI
 737    relocations.  The REFHI relocation must be followed by a REFLO
 738    relocation, and the addend used is formed from the addends of both
 739    instructions.  */
 740
 741 static void
 742 mips_relocate_hi (struct internal_reloc *refhi,
 743                   struct internal_reloc *reflo,
 744                   bfd *input_bfd,
 745                   asection *input_section,
 746                   bfd_byte *contents,
 747                   bfd_vma relocation)
 748 {
 749   unsigned long insn;
 750   unsigned long val;
 751   unsigned long vallo;
 752
 753   if (refhi == NULL)
 754     return;
 755
 756   insn = bfd_get_32 (input_bfd,
 757                      contents + refhi->r_vaddr - input_section->vma);
 758   if (reflo == NULL)
 759     vallo = 0;
 760   else
 761     vallo = (bfd_get_32 (input_bfd,
 762                          contents + reflo->r_vaddr - input_section->vma)
 763              & 0xffff);
 764
 765   val = ((insn & 0xffff) << 16) + vallo;
 766   val += relocation;
 767
 768   /* The low order 16 bits are always treated as a signed value.
 769      Therefore, a negative value in the low order bits requires an
 770      adjustment in the high order bits.  We need to make this
 771      adjustment in two ways: once for the bits we took from the data,
 772      and once for the bits we are putting back in to the data.  */
 773   if ((vallo & 0x8000) != 0)
 774     val -= 0x10000;
 775
 776   if ((val & 0x8000) != 0)
 777     val += 0x10000;
 778
 779   insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
 780   bfd_put_32 (input_bfd, (bfd_vma) insn,
 781               contents + refhi->r_vaddr - input_section->vma);
 782 }
 783
 784 /* Relocate a section while linking a MIPS ECOFF file.  */
 785
 786 static bfd_boolean
 787 mips_relocate_section (bfd *output_bfd,
 788                        struct bfd_link_info *info,
 789                        bfd *input_bfd,
 790                        asection *input_section,
 791                        bfd_byte *contents,
 792                        void * external_relocs)
 793 {
 794   asection **symndx_to_section;
 795   struct ecoff_link_hash_entry **sym_hashes;
 796   bfd_vma gp;
 797   bfd_boolean gp_undefined;
 798   struct external_reloc *ext_rel;
 799   struct external_reloc *ext_rel_end;
 800   unsigned int i;
 801   bfd_boolean got_lo;
 802   struct internal_reloc lo_int_rel;
 803   bfd_size_type amt;
 804
 805   BFD_ASSERT (input_bfd->xvec->byteorder
 806               == output_bfd->xvec->byteorder);
 807
 808   /* We keep a table mapping the symndx found in an internal reloc to
 809      the appropriate section.  This is faster than looking up the
 810      section by name each time.  */
 811   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
 812   if (symndx_to_section == (asection **) NULL)
 813     {
 814       amt = NUM_RELOC_SECTIONS * sizeof (asection *);
 815       symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
 816       if (!symndx_to_section)
 817         return FALSE;
 818
 819       symndx_to_section[RELOC_SECTION_NONE] = NULL;
 820       symndx_to_section[RELOC_SECTION_TEXT] =
 821         bfd_get_section_by_name (input_bfd, ".text");
 822       symndx_to_section[RELOC_SECTION_RDATA] =
 823         bfd_get_section_by_name (input_bfd, ".rdata");
 824       symndx_to_section[RELOC_SECTION_DATA] =
 825         bfd_get_section_by_name (input_bfd, ".data");
 826       symndx_to_section[RELOC_SECTION_SDATA] =
 827         bfd_get_section_by_name (input_bfd, ".sdata");
 828       symndx_to_section[RELOC_SECTION_SBSS] =
 829         bfd_get_section_by_name (input_bfd, ".sbss");
 830       symndx_to_section[RELOC_SECTION_BSS] =
 831         bfd_get_section_by_name (input_bfd, ".bss");
 832       symndx_to_section[RELOC_SECTION_INIT] =
 833         bfd_get_section_by_name (input_bfd, ".init");
 834       symndx_to_section[RELOC_SECTION_LIT8] =
 835         bfd_get_section_by_name (input_bfd, ".lit8");
 836       symndx_to_section[RELOC_SECTION_LIT4] =
 837         bfd_get_section_by_name (input_bfd, ".lit4");
 838       symndx_to_section[RELOC_SECTION_XDATA] = NULL;
 839       symndx_to_section[RELOC_SECTION_PDATA] = NULL;
 840       symndx_to_section[RELOC_SECTION_FINI] =
 841         bfd_get_section_by_name (input_bfd, ".fini");
 842       symndx_to_section[RELOC_SECTION_LITA] = NULL;
 843       symndx_to_section[RELOC_SECTION_ABS] = NULL;
 844
 845       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
 846     }
 847
 848   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
 849
 850   gp = _bfd_get_gp_value (output_bfd);
 851   if (gp == 0)
 852     gp_undefined = TRUE;
 853   else
 854     gp_undefined = FALSE;
 855
 856   got_lo = FALSE;
 857
 858   ext_rel = (struct external_reloc *) external_relocs;
 859   ext_rel_end = ext_rel + input_section->reloc_count;
 860   for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
 861     {
 862       struct internal_reloc int_rel;
 863       bfd_boolean use_lo = FALSE;
 864       bfd_vma addend;
 865       reloc_howto_type *howto;
 866       struct ecoff_link_hash_entry *h = NULL;
 867       asection *s = NULL;
 868       bfd_vma relocation;
 869       bfd_reloc_status_type r;
 870
 871       if (! got_lo)
 872         mips_ecoff_swap_reloc_in (input_bfd, ext_rel, &int_rel);
 873       else
 874         {
 875           int_rel = lo_int_rel;
 876           got_lo = FALSE;
 877         }
 878
 879       BFD_ASSERT (int_rel.r_type
 880                   < sizeof mips_howto_table / sizeof mips_howto_table[0]);
 881
 882       /* The REFHI reloc requires special handling.  It must be followed
 883          by a REFLO reloc, and the addend is formed from both relocs.  */
 884       if (int_rel.r_type == MIPS_R_REFHI)
 885         {
 886           struct external_reloc *lo_ext_rel;
 887
 888           /* As a GNU extension, permit an arbitrary number of REFHI
 889              relocs before the REFLO reloc.  This permits gcc to emit
 890              the HI and LO relocs itself.  */
 891           for (lo_ext_rel = ext_rel + 1;
 892                lo_ext_rel < ext_rel_end;
 893                lo_ext_rel++)
 894             {
 895               mips_ecoff_swap_reloc_in (input_bfd, lo_ext_rel,
 896                                         &lo_int_rel);
 897               if (lo_int_rel.r_type != int_rel.r_type)
 898                 break;
 899             }
 900
 901           if (lo_ext_rel < ext_rel_end
 902               && lo_int_rel.r_type == MIPS_R_REFLO
 903               && int_rel.r_extern == lo_int_rel.r_extern
 904               && int_rel.r_symndx == lo_int_rel.r_symndx)
 905             {
 906               use_lo = TRUE;
 907               if (lo_ext_rel == ext_rel + 1)
 908                 got_lo = TRUE;
 909             }
 910         }
 911
 912       howto = &mips_howto_table[int_rel.r_type];
 913
 914       if (int_rel.r_extern)
 915         {
 916           h = sym_hashes[int_rel.r_symndx];
 917           /* If h is NULL, that means that there is a reloc against an
 918              external symbol which we thought was just a debugging
 919              symbol.  This should not happen.  */
 920           if (h == (struct ecoff_link_hash_entry *) NULL)
 921             abort ();
 922         }
 923       else
 924         {
 925           if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
 926             s = NULL;
 927           else
 928             s = symndx_to_section[int_rel.r_symndx];
 929
 930           if (s == (asection *) NULL)
 931             abort ();
 932         }
 933
 934       /* The GPREL reloc uses an addend: the difference in the GP
 935          values.  */
 936       if (int_rel.r_type != MIPS_R_GPREL
 937           && int_rel.r_type != MIPS_R_LITERAL)
 938         addend = 0;
 939       else
 940         {
 941           if (gp_undefined)
 942             {
 943               if (! ((*info->callbacks->reloc_dangerous)
 944                      (info, _("GP relative relocation used when GP not defined"),
 945                       input_bfd, input_section,
 946                       int_rel.r_vaddr - input_section->vma)))
 947                 return FALSE;
 948               /* Only give the error once per link.  */
 949               gp = 4;
 950               _bfd_set_gp_value (output_bfd, gp);
 951               gp_undefined = FALSE;
 952             }
 953           if (! int_rel.r_extern)
 954             {
 955               /* This is a relocation against a section.  The current
 956                  addend in the instruction is the difference between
 957                  INPUT_SECTION->vma and the GP value of INPUT_BFD.  We
 958                  must change this to be the difference between the
 959                  final definition (which will end up in RELOCATION)
 960                  and the GP value of OUTPUT_BFD (which is in GP).  */
 961               addend = ecoff_data (input_bfd)->gp - gp;
 962             }
 963           else if (! bfd_link_relocatable (info)
 964                    || h->root.type == bfd_link_hash_defined
 965                    || h->root.type == bfd_link_hash_defweak)
 966             {
 967               /* This is a relocation against a defined symbol.  The
 968                  current addend in the instruction is simply the
 969                  desired offset into the symbol (normally zero).  We
 970                  are going to change this into a relocation against a
 971                  defined symbol, so we want the instruction to hold
 972                  the difference between the final definition of the
 973                  symbol (which will end up in RELOCATION) and the GP
 974                  value of OUTPUT_BFD (which is in GP).  */
 975               addend = - gp;
 976             }
 977           else
 978             {
 979               /* This is a relocation against an undefined or common
 980                  symbol.  The current addend in the instruction is
 981                  simply the desired offset into the symbol (normally
 982                  zero).  We are generating relocatable output, and we
 983                  aren't going to define this symbol, so we just leave
 984                  the instruction alone.  */
 985               addend = 0;
 986             }
 987         }
 988
 989       if (bfd_link_relocatable (info))
 990         {
 991           /* We are generating relocatable output, and must convert
 992              the existing reloc.  */
 993           if (int_rel.r_extern)
 994             {
 995               if ((h->root.type == bfd_link_hash_defined
 996                    || h->root.type == bfd_link_hash_defweak)
 997                   && ! bfd_is_abs_section (h->root.u.def.section))
 998                 {
 999                   const char *name;
1000
1001                   /* This symbol is defined in the output.  Convert
1002                      the reloc from being against the symbol to being
1003                      against the section.  */
1004
1005                   /* Clear the r_extern bit.  */
1006                   int_rel.r_extern = 0;
1007
1008                   /* Compute a new r_symndx value.  */
1009                   s = h->root.u.def.section;
1010                   name = bfd_get_section_name (output_bfd,
1011                                                s->output_section);
1012
1013                   int_rel.r_symndx = -1;
1014                   switch (name[1])
1015                     {
1016                     case 'b':
1017                       if (strcmp (name, ".bss") == 0)
1018                         int_rel.r_symndx = RELOC_SECTION_BSS;
1019                       break;
1020                     case 'd':
1021                       if (strcmp (name, ".data") == 0)
1022                         int_rel.r_symndx = RELOC_SECTION_DATA;
1023                       break;
1024                     case 'f':
1025                       if (strcmp (name, ".fini") == 0)
1026                         int_rel.r_symndx = RELOC_SECTION_FINI;
1027                       break;
1028                     case 'i':
1029                       if (strcmp (name, ".init") == 0)
1030                         int_rel.r_symndx = RELOC_SECTION_INIT;
1031                       break;
1032                     case 'l':
1033                       if (strcmp (name, ".lit8") == 0)
1034                         int_rel.r_symndx = RELOC_SECTION_LIT8;
1035                       else if (strcmp (name, ".lit4") == 0)
1036                         int_rel.r_symndx = RELOC_SECTION_LIT4;
1037                       break;
1038                     case 'r':
1039                       if (strcmp (name, ".rdata") == 0)
1040                         int_rel.r_symndx = RELOC_SECTION_RDATA;
1041                       break;
1042                     case 's':
1043                       if (strcmp (name, ".sdata") == 0)
1044                         int_rel.r_symndx = RELOC_SECTION_SDATA;
1045                       else if (strcmp (name, ".sbss") == 0)
1046                         int_rel.r_symndx = RELOC_SECTION_SBSS;
1047                       break;
1048                     case 't':
1049                       if (strcmp (name, ".text") == 0)
1050                         int_rel.r_symndx = RELOC_SECTION_TEXT;
1051                       break;
1052                     }
1053
1054                   if (int_rel.r_symndx == -1)
1055                     abort ();
1056
1057                   /* Add the section VMA and the symbol value.  */
1058                   relocation = (h->root.u.def.value
1059                                 + s->output_section->vma
1060                                 + s->output_offset);
1061
1062                   /* For a PC relative relocation, the object file
1063                      currently holds just the addend.  We must adjust
1064                      by the address to get the right value.  */
1065                   if (howto->pc_relative)
1066                     relocation -= int_rel.r_vaddr - input_section->vma;
1067
1068                   h = NULL;
1069                 }
1070               else
1071                 {
1072                   /* Change the symndx value to the right one for the
1073                      output BFD.  */
1074                   int_rel.r_symndx = h->indx;
1075                   if (int_rel.r_symndx == -1)
1076                     {
1077                       /* This symbol is not being written out.  */
1078                       if (! ((*info->callbacks->unattached_reloc)
1079                              (info, h->root.root.string, input_bfd,
1080                               input_section,
1081                               int_rel.r_vaddr - input_section->vma)))
1082                         return FALSE;
1083                       int_rel.r_symndx = 0;
1084                     }
1085                   relocation = 0;
1086                 }
1087             }
1088           else
1089             {
1090               /* This is a relocation against a section.  Adjust the
1091                  value by the amount the section moved.  */
1092               relocation = (s->output_section->vma
1093                             + s->output_offset
1094                             - s->vma);
1095             }
1096
1097           relocation += addend;
1098           addend = 0;
1099
1100           /* Adjust a PC relative relocation by removing the reference
1101              to the original address in the section and including the
1102              reference to the new address.  */
1103           if (howto->pc_relative)
1104             relocation -= (input_section->output_section->vma
1105                            + input_section->output_offset
1106                            - input_section->vma);
1107
1108           /* Adjust the contents.  */
1109           if (relocation == 0)
1110             r = bfd_reloc_ok;
1111           else
1112             {
1113               if (int_rel.r_type != MIPS_R_REFHI)
1114                 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1115                                             (contents
1116                                              + int_rel.r_vaddr
1117                                              - input_section->vma));
1118               else
1119                 {
1120                   mips_relocate_hi (&int_rel,
1121                                     use_lo ? &lo_int_rel : NULL,
1122                                     input_bfd, input_section, contents,
1123                                     relocation);
1124                   r = bfd_reloc_ok;
1125                 }
1126             }
1127
1128           /* Adjust the reloc address.  */
1129           int_rel.r_vaddr += (input_section->output_section->vma
1130                               + input_section->output_offset
1131                               - input_section->vma);
1132
1133           /* Save the changed reloc information.  */
1134           mips_ecoff_swap_reloc_out (input_bfd, &int_rel, ext_rel);
1135         }
1136       else
1137         {
1138           /* We are producing a final executable.  */
1139           if (int_rel.r_extern)
1140             {
1141               /* This is a reloc against a symbol.  */
1142               if (h->root.type == bfd_link_hash_defined
1143                   || h->root.type == bfd_link_hash_defweak)
1144                 {
1145                   asection *hsec;
1146
1147                   hsec = h->root.u.def.section;
1148                   relocation = (h->root.u.def.value
1149                                 + hsec->output_section->vma
1150                                 + hsec->output_offset);
1151                 }
1152               else
1153                 {
1154                   if (! ((*info->callbacks->undefined_symbol)
1155                          (info, h->root.root.string, input_bfd,
1156                           input_section,
1157                           int_rel.r_vaddr - input_section->vma, TRUE)))
1158                     return FALSE;
1159                   relocation = 0;
1160                 }
1161             }
1162           else
1163             {
1164               /* This is a reloc against a section.  */
1165               relocation = (s->output_section->vma
1166                             + s->output_offset
1167                             - s->vma);
1168
1169               /* A PC relative reloc is already correct in the object
1170                  file.  Make it look like a pcrel_offset relocation by
1171                  adding in the start address.  */
1172               if (howto->pc_relative)
1173                 relocation += int_rel.r_vaddr;
1174             }
1175
1176           if (int_rel.r_type != MIPS_R_REFHI)
1177             r = _bfd_final_link_relocate (howto,
1178                                           input_bfd,
1179                                           input_section,
1180                                           contents,
1181                                           (int_rel.r_vaddr
1182                                            - input_section->vma),
1183                                           relocation,
1184                                           addend);
1185           else
1186             {
1187               mips_relocate_hi (&int_rel,
1188                                 use_lo ? &lo_int_rel : NULL,
1189                                 input_bfd, input_section, contents,
1190                                 relocation);
1191               r = bfd_reloc_ok;
1192             }
1193         }
1194
1195       /* MIPS_R_JMPADDR requires peculiar overflow detection.  The
1196          instruction provides a 28 bit address (the two lower bits are
1197          implicit zeroes) which is combined with the upper four bits
1198          of the instruction address.  */
1199       if (r == bfd_reloc_ok
1200           && int_rel.r_type == MIPS_R_JMPADDR
1201           && (((relocation
1202                 + addend
1203                 + (int_rel.r_extern ? 0 : s->vma))
1204                & 0xf0000000)
1205               != ((input_section->output_section->vma
1206                    + input_section->output_offset
1207                    + (int_rel.r_vaddr - input_section->vma))
1208                   & 0xf0000000)))
1209         r = bfd_reloc_overflow;
1210
1211       if (r != bfd_reloc_ok)
1212         {
1213           switch (r)
1214             {
1215             default:
1216             case bfd_reloc_outofrange:
1217               abort ();
1218             case bfd_reloc_overflow:
1219               {
1220                 const char *name;
1221
1222                 if (int_rel.r_extern)
1223                   name = NULL;
1224                 else
1225                   name = bfd_section_name (input_bfd, s);
1226                 if (! ((*info->callbacks->reloc_overflow)
1227                        (info, (h ? &h->root : NULL), name, howto->name,
1228                         (bfd_vma) 0, input_bfd, input_section,
1229                         int_rel.r_vaddr - input_section->vma)))
1230                   return FALSE;
1231               }
1232               break;
1233             }
1234         }
1235     }
1236
1237   return TRUE;
1238 }
1239 \f
1240 /* This is the ECOFF backend structure.  The backend field of the
1241    target vector points to this.  */
1242
1243 static const struct ecoff_backend_data mips_ecoff_backend_data =
1244 {
1245   /* COFF backend structure.  */
1246   {
1247     (void (*) (bfd *,void *,int,int,int,int,void *)) bfd_void, /* aux_in */
1248     (void (*) (bfd *,void *,void *)) bfd_void, /* sym_in */
1249     (void (*) (bfd *,void *,void *)) bfd_void, /* lineno_in */
1250     (unsigned (*) (bfd *,void *,int,int,int,int,void *)) bfd_void,/*aux_out*/
1251     (unsigned (*) (bfd *,void *,void *)) bfd_void, /* sym_out */
1252     (unsigned (*) (bfd *,void *,void *)) bfd_void, /* lineno_out */
1253     (unsigned (*) (bfd *,void *,void *)) bfd_void, /* reloc_out */
1254     mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
1255     mips_ecoff_swap_scnhdr_out,
1256     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE,
1257     ECOFF_NO_LONG_SECTION_NAMES, 4, FALSE, 2, 32768,
1258     mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
1259     mips_ecoff_swap_scnhdr_in, NULL,
1260     mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1261     _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1262     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1263     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1264     NULL, NULL, NULL
1265   },
1266   /* Supported architecture.  */
1267   bfd_arch_mips,
1268   /* Initial portion of armap string.  */
1269   "__________",
1270   /* The page boundary used to align sections in a demand-paged
1271      executable file.  E.g., 0x1000.  */
1272   0x1000,
1273   /* TRUE if the .rdata section is part of the text segment, as on the
1274      Alpha.  FALSE if .rdata is part of the data segment, as on the
1275      MIPS.  */
1276   FALSE,
1277   /* Bitsize of constructor entries.  */
1278   32,
1279   /* Reloc to use for constructor entries.  */
1280   &mips_howto_table[MIPS_R_REFWORD],
1281   {
1282     /* Symbol table magic number.  */
1283     magicSym,
1284     /* Alignment of debugging information.  E.g., 4.  */
1285     4,
1286     /* Sizes of external symbolic information.  */
1287     sizeof (struct hdr_ext),
1288     sizeof (struct dnr_ext),
1289     sizeof (struct pdr_ext),
1290     sizeof (struct sym_ext),
1291     sizeof (struct opt_ext),
1292     sizeof (struct fdr_ext),
1293     sizeof (struct rfd_ext),
1294     sizeof (struct ext_ext),
1295     /* Functions to swap in external symbolic data.  */
1296     ecoff_swap_hdr_in,
1297     ecoff_swap_dnr_in,
1298     ecoff_swap_pdr_in,
1299     ecoff_swap_sym_in,
1300     ecoff_swap_opt_in,
1301     ecoff_swap_fdr_in,
1302     ecoff_swap_rfd_in,
1303     ecoff_swap_ext_in,
1304     _bfd_ecoff_swap_tir_in,
1305     _bfd_ecoff_swap_rndx_in,
1306     /* Functions to swap out external symbolic data.  */
1307     ecoff_swap_hdr_out,
1308     ecoff_swap_dnr_out,
1309     ecoff_swap_pdr_out,
1310     ecoff_swap_sym_out,
1311     ecoff_swap_opt_out,
1312     ecoff_swap_fdr_out,
1313     ecoff_swap_rfd_out,
1314     ecoff_swap_ext_out,
1315     _bfd_ecoff_swap_tir_out,
1316     _bfd_ecoff_swap_rndx_out,
1317     /* Function to read in symbolic data.  */
1318     _bfd_ecoff_slurp_symbolic_info
1319   },
1320   /* External reloc size.  */
1321   RELSZ,
1322   /* Reloc swapping functions.  */
1323   mips_ecoff_swap_reloc_in,
1324   mips_ecoff_swap_reloc_out,
1325   /* Backend reloc tweaking.  */
1326   mips_adjust_reloc_in,
1327   mips_adjust_reloc_out,
1328   /* Relocate section contents while linking.  */
1329   mips_relocate_section,
1330   /* Do final adjustments to filehdr and aouthdr.  */
1331   NULL,
1332   /* Read an element from an archive at a given file position.  */
1333   _bfd_get_elt_at_filepos
1334 };
1335
1336 /* Looking up a reloc type is MIPS specific.  */
1337 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1338 #define _bfd_ecoff_bfd_reloc_name_lookup mips_bfd_reloc_name_lookup
1339
1340 /* Getting relocated section contents is generic.  */
1341 #define _bfd_ecoff_bfd_get_relocated_section_contents \
1342   bfd_generic_get_relocated_section_contents
1343
1344 /* Handling file windows is generic.  */
1345 #define _bfd_ecoff_get_section_contents_in_window \
1346   _bfd_generic_get_section_contents_in_window
1347
1348 /* Relaxing sections is MIPS specific.  */
1349 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1350
1351 /* GC of sections is not done.  */
1352 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1353
1354 /* Input section flags is not implemented.  */
1355 #define _bfd_ecoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
1356
1357 /* Merging of sections is not done.  */
1358 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1359
1360 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1361 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1362 #define _bfd_ecoff_section_already_linked \
1363   _bfd_coff_section_already_linked
1364 #define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol
1365
1366 extern const bfd_target mips_ecoff_be_vec;
1367
1368 const bfd_target mips_ecoff_le_vec =
1369 {
1370   "ecoff-littlemips",           /* name */
1371   bfd_target_ecoff_flavour,
1372   BFD_ENDIAN_LITTLE,            /* data byte order is little */
1373   BFD_ENDIAN_LITTLE,            /* header byte order is little */
1374
1375   (HAS_RELOC | EXEC_P |         /* object flags */
1376    HAS_LINENO | HAS_DEBUG |
1377    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1378
1379   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1380   0,                            /* leading underscore */
1381   ' ',                          /* ar_pad_char */
1382   15,                           /* ar_max_namelen */
1383   0,                            /* match priority.  */
1384   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1385      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1386      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1387   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1388      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1389      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1390
1391   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1392      bfd_generic_archive_p, _bfd_dummy_target},
1393   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
1394      _bfd_generic_mkarchive, bfd_false},
1395   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1396      _bfd_write_archive_contents, bfd_false},
1397
1398      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1399      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1400      BFD_JUMP_TABLE_CORE (_bfd_nocore),
1401      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1402      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1403      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1404      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1405      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1406      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1407
1408   & mips_ecoff_be_vec,
1409
1410   & mips_ecoff_backend_data
1411 };
1412
1413 const bfd_target mips_ecoff_be_vec =
1414 {
1415   "ecoff-bigmips",              /* name */
1416   bfd_target_ecoff_flavour,
1417   BFD_ENDIAN_BIG,               /* data byte order is big */
1418   BFD_ENDIAN_BIG,               /* header byte order is big */
1419
1420   (HAS_RELOC | EXEC_P |         /* object flags */
1421    HAS_LINENO | HAS_DEBUG |
1422    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1423
1424   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1425   0,                            /* leading underscore */
1426   ' ',                          /* ar_pad_char */
1427   15,                           /* ar_max_namelen */
1428   0,                            /* match priority.  */
1429   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1430      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1431      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1432   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1433      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1434      bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1435  {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1436     bfd_generic_archive_p, _bfd_dummy_target},
1437  {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1438     _bfd_generic_mkarchive, bfd_false},
1439  {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1440     _bfd_write_archive_contents, bfd_false},
1441
1442      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1443      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1444      BFD_JUMP_TABLE_CORE (_bfd_nocore),
1445      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1446      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1447      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1448      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1449      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1450      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1451
1452   & mips_ecoff_le_vec,
1453
1454   & mips_ecoff_backend_data
1455 };
1456
1457 const bfd_target mips_ecoff_bele_vec =
1458 {
1459   "ecoff-biglittlemips",                /* name */
1460   bfd_target_ecoff_flavour,
1461   BFD_ENDIAN_LITTLE,            /* data byte order is little */
1462   BFD_ENDIAN_BIG,               /* header byte order is big */
1463
1464   (HAS_RELOC | EXEC_P |         /* object flags */
1465    HAS_LINENO | HAS_DEBUG |
1466    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1467
1468   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1469   0,                            /* leading underscore */
1470   ' ',                          /* ar_pad_char */
1471   15,                           /* ar_max_namelen */
1472   0,                            /* match priority.  */
1473   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1474      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1475      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1476   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1477      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1478      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1479
1480   {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1481      bfd_generic_archive_p, _bfd_dummy_target},
1482   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
1483      _bfd_generic_mkarchive, bfd_false},
1484   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1485      _bfd_write_archive_contents, bfd_false},
1486
1487      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1488      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1489      BFD_JUMP_TABLE_CORE (_bfd_nocore),
1490      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1491      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1492      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1493      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1494      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1495      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1496
1497   NULL,
1498
1499   & mips_ecoff_backend_data
1500 };