bfd/pe-mips.c

   1 /* BFD back-end for MIPS PE COFF files.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
   3    Modified from coff-i386.c by DJ Delorie, dj@cygnus.com
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #define COFF_WITH_PE
  22 #define COFF_LONG_SECTION_NAMES
  23 #define PCRELOFFSET true
  24
  25 #include "bfd.h"
  26 #include "sysdep.h"
  27 #include "libbfd.h"
  28
  29 #include "coff/mipspe.h"
  30
  31 #include "coff/internal.h"
  32
  33 #include "coff/pe.h"
  34
  35 #include "libcoff.h"
  36
  37 static bfd_reloc_status_type coff_mips_reloc
  38   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  39 static reloc_howto_type *coff_mips_rtype_to_howto
  40   PARAMS ((bfd *, asection *, struct internal_reloc *,
  41            struct coff_link_hash_entry *, struct internal_syment *,
  42
  43            bfd_vma *));
  44 #if 0
  45 static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
  46                                               struct internal_reloc *));
  47 static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
  48                                                const struct internal_reloc *,
  49                                                PTR));
  50 static void mips_adjust_reloc_in PARAMS ((bfd *,
  51                                           const struct internal_reloc *,
  52                                           arelent *));
  53 static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
  54                                            struct internal_reloc *));
  55 #endif
  56 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
  57 /* The page size is a guess based on ELF.  */
  58
  59 #define COFF_PAGE_SIZE 0x1000
  60
  61 /* For some reason when using mips COFF the value stored in the .text
  62    section for a reference to a common symbol is the value itself plus
  63    any desired offset.  Ian Taylor, Cygnus Support.  */
  64
  65 /* If we are producing relocateable output, we need to do some
  66    adjustments to the object file that are not done by the
  67    bfd_perform_relocation function.  This function is called by every
  68    reloc type to make any required adjustments.  */
  69
  70 static bfd_reloc_status_type
  71 coff_mips_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
  72                  error_message)
  73      bfd *abfd;
  74      arelent *reloc_entry;
  75      asymbol *symbol;
  76      PTR data;
  77      asection *input_section ATTRIBUTE_UNUSED;
  78      bfd *output_bfd;
  79      char **error_message ATTRIBUTE_UNUSED;
  80 {
  81   symvalue diff;
  82
  83   if (output_bfd == (bfd *) NULL)
  84     return bfd_reloc_continue;
  85
  86   if (bfd_is_com_section (symbol->section))
  87     {
  88 #ifndef COFF_WITH_PE
  89       /* We are relocating a common symbol.  The current value in the
  90          object file is ORIG + OFFSET, where ORIG is the value of the
  91          common symbol as seen by the object file when it was compiled
  92          (this may be zero if the symbol was undefined) and OFFSET is
  93          the offset into the common symbol (normally zero, but may be
  94          non-zero when referring to a field in a common structure).
  95          ORIG is the negative of reloc_entry->addend, which is set by
  96          the CALC_ADDEND macro below.  We want to replace the value in
  97          the object file with NEW + OFFSET, where NEW is the value of
  98          the common symbol which we are going to put in the final
  99          object file.  NEW is symbol->value.  */
 100       diff = symbol->value + reloc_entry->addend;
 101 #else
 102       /* In PE mode, we do not offset the common symbol.  */
 103       diff = reloc_entry->addend;
 104 #endif
 105     }
 106   else
 107     {
 108       /* For some reason bfd_perform_relocation always effectively
 109          ignores the addend for a COFF target when producing
 110          relocateable output.  This seems to be always wrong for 386
 111          COFF, so we handle the addend here instead.  */
 112       diff = reloc_entry->addend;
 113     }
 114
 115 #ifdef COFF_WITH_PE
 116 #if 0
 117   /* dj - handle it like any other reloc? */
 118   /* FIXME: How should this case be handled?  */
 119   if (reloc_entry->howto->type == MIPS_R_RVA && diff != 0)
 120     abort ();
 121 #endif
 122 #endif
 123
 124 #define DOIT(x) \
 125   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
 126
 127     if (diff != 0)
 128       {
 129         reloc_howto_type *howto = reloc_entry->howto;
 130         unsigned char *addr = (unsigned char *) data + reloc_entry->address;
 131
 132         switch (howto->size)
 133           {
 134           case 0:
 135             {
 136               char x = bfd_get_8 (abfd, addr);
 137               DOIT (x);
 138               bfd_put_8 (abfd, x, addr);
 139             }
 140             break;
 141
 142           case 1:
 143             {
 144               short x = bfd_get_16 (abfd, addr);
 145               DOIT (x);
 146               bfd_put_16 (abfd, x, addr);
 147             }
 148             break;
 149
 150           case 2:
 151             {
 152               long x = bfd_get_32 (abfd, addr);
 153               DOIT (x);
 154               bfd_put_32 (abfd, x, addr);
 155             }
 156             break;
 157
 158           default:
 159             abort ();
 160           }
 161       }
 162
 163   /* Now let bfd_perform_relocation finish everything up.  */
 164   return bfd_reloc_continue;
 165 }
 166
 167 #ifdef COFF_WITH_PE
 168 /* Return true if this relocation should
 169    appear in the output .reloc section. */
 170
 171 static boolean in_reloc_p(abfd, howto)
 172      bfd * abfd ATTRIBUTE_UNUSED;
 173      reloc_howto_type *howto;
 174 {
 175   return ! howto->pc_relative && howto->type != MIPS_R_RVA;
 176 }
 177 #endif
 178
 179 #ifndef PCRELOFFSET
 180 #define PCRELOFFSET false
 181 #endif
 182
 183 static reloc_howto_type howto_table[] =
 184 {
 185   /* Reloc type 0 is ignored.  The reloc reading code ensures that
 186      this is a reference to the .abs section, which will cause
 187      bfd_perform_relocation to do nothing.  */
 188   HOWTO (MIPS_R_ABSOLUTE,       /* type */
 189          0,                     /* rightshift */
 190          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 191          8,                     /* bitsize */
 192          false,                 /* pc_relative */
 193          0,                     /* bitpos */
 194          complain_overflow_dont, /* complain_on_overflow */
 195          0,                     /* special_function */
 196          "IGNORE",              /* name */
 197          false,                 /* partial_inplace */
 198          0,                     /* src_mask */
 199          0,                     /* dst_mask */
 200          false),                /* pcrel_offset */
 201
 202   /* A 16 bit reference to a symbol, normally from a data section.  */
 203   HOWTO (MIPS_R_REFHALF,        /* type */
 204          0,                     /* rightshift */
 205          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 206          16,                    /* bitsize */
 207          false,                 /* pc_relative */
 208          0,                     /* bitpos */
 209          complain_overflow_bitfield, /* complain_on_overflow */
 210          coff_mips_reloc,       /* special_function */
 211          "REFHALF",             /* name */
 212          true,                  /* partial_inplace */
 213          0xffff,                /* src_mask */
 214          0xffff,                /* dst_mask */
 215          false),                /* pcrel_offset */
 216
 217   /* A 32 bit reference to a symbol, normally from a data section.  */
 218   HOWTO (MIPS_R_REFWORD,        /* type */
 219          0,                     /* rightshift */
 220          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 221          32,                    /* bitsize */
 222          false,                 /* pc_relative */
 223          0,                     /* bitpos */
 224          complain_overflow_bitfield, /* complain_on_overflow */
 225          coff_mips_reloc,       /* special_function */
 226          "REFWORD",             /* name */
 227          true,                  /* partial_inplace */
 228          0xffffffff,            /* src_mask */
 229          0xffffffff,            /* dst_mask */
 230          false),                /* pcrel_offset */
 231
 232   /* A 26 bit absolute jump address.  */
 233   HOWTO (MIPS_R_JMPADDR,        /* type */
 234          2,                     /* rightshift */
 235          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 236          26,                    /* bitsize */
 237          false,                 /* pc_relative */
 238          0,                     /* bitpos */
 239          complain_overflow_dont, /* complain_on_overflow */
 240                                 /* This needs complex overflow
 241                                    detection, because the upper four
 242                                    bits must match the PC.  */
 243          coff_mips_reloc,       /* special_function */
 244          "JMPADDR",             /* name */
 245          true,                  /* partial_inplace */
 246          0x3ffffff,             /* src_mask */
 247          0x3ffffff,             /* dst_mask */
 248          false),                /* pcrel_offset */
 249
 250   /* The high 16 bits of a symbol value.  Handled by the function
 251      mips_refhi_reloc.  */
 252   HOWTO (MIPS_R_REFHI,          /* type */
 253          16,                    /* rightshift */
 254          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 255          16,                    /* bitsize */
 256          false,                 /* pc_relative */
 257          0,                     /* bitpos */
 258          complain_overflow_bitfield, /* complain_on_overflow */
 259          coff_mips_reloc,       /* special_function */
 260          "REFHI",               /* name */
 261          true,                  /* partial_inplace */
 262          0xffff,                /* src_mask */
 263          0xffff,                /* dst_mask */
 264          false),                /* pcrel_offset */
 265
 266   /* The low 16 bits of a symbol value.  */
 267   HOWTO (MIPS_R_REFLO,          /* type */
 268          0,                     /* rightshift */
 269          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 270          16,                    /* bitsize */
 271          false,                 /* pc_relative */
 272          0,                     /* bitpos */
 273          complain_overflow_dont, /* complain_on_overflow */
 274          coff_mips_reloc,       /* special_function */
 275          "REFLO",               /* name */
 276          true,                  /* partial_inplace */
 277          0xffff,                /* src_mask */
 278          0xffff,                /* dst_mask */
 279          false),                /* pcrel_offset */
 280
 281   /* A reference to an offset from the gp register.  Handled by the
 282      function mips_gprel_reloc.  */
 283   HOWTO (MIPS_R_GPREL,          /* type */
 284          0,                     /* rightshift */
 285          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          16,                    /* bitsize */
 287          false,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_signed, /* complain_on_overflow */
 290          coff_mips_reloc,       /* special_function */
 291          "GPREL",               /* name */
 292          true,                  /* partial_inplace */
 293          0xffff,                /* src_mask */
 294          0xffff,                /* dst_mask */
 295          false),                /* pcrel_offset */
 296
 297   /* A reference to a literal using an offset from the gp register.
 298      Handled by the function mips_gprel_reloc.  */
 299   HOWTO (MIPS_R_LITERAL,        /* type */
 300          0,                     /* rightshift */
 301          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 302          16,                    /* bitsize */
 303          false,                 /* pc_relative */
 304          0,                     /* bitpos */
 305          complain_overflow_signed, /* complain_on_overflow */
 306          coff_mips_reloc,       /* special_function */
 307          "LITERAL",             /* name */
 308          true,                  /* partial_inplace */
 309          0xffff,                /* src_mask */
 310          0xffff,                /* dst_mask */
 311          false),                /* pcrel_offset */
 312
 313   EMPTY_HOWTO (8),
 314   EMPTY_HOWTO (9),
 315   EMPTY_HOWTO (10),
 316   EMPTY_HOWTO (11),
 317   EMPTY_HOWTO (12),
 318   EMPTY_HOWTO (13),
 319   EMPTY_HOWTO (14),
 320   EMPTY_HOWTO (15),
 321   EMPTY_HOWTO (16),
 322   EMPTY_HOWTO (17),
 323   EMPTY_HOWTO (18),
 324   EMPTY_HOWTO (19),
 325   EMPTY_HOWTO (20),
 326   EMPTY_HOWTO (21),
 327   EMPTY_HOWTO (22),
 328   EMPTY_HOWTO (23),
 329   EMPTY_HOWTO (24),
 330   EMPTY_HOWTO (25),
 331   EMPTY_HOWTO (26),
 332   EMPTY_HOWTO (27),
 333   EMPTY_HOWTO (28),
 334   EMPTY_HOWTO (29),
 335   EMPTY_HOWTO (30),
 336   EMPTY_HOWTO (31),
 337   EMPTY_HOWTO (32),
 338   EMPTY_HOWTO (33),
 339   HOWTO (MIPS_R_RVA,            /* type */
 340          0,                     /* rightshift */
 341          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          32,                    /* bitsize */
 343          false,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_bitfield, /* complain_on_overflow */
 346          coff_mips_reloc,       /* special_function */
 347          "rva32",               /* name */
 348          true,                  /* partial_inplace */
 349          0xffffffff,            /* src_mask */
 350          0xffffffff,            /* dst_mask */
 351          false),                /* pcrel_offset */
 352   EMPTY_HOWTO (35),
 353   EMPTY_HOWTO (36),
 354   HOWTO (MIPS_R_PAIR,           /* type */
 355          0,                     /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          32,                    /* bitsize */
 358          false,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_bitfield, /* complain_on_overflow */
 361          coff_mips_reloc,       /* special_function */
 362          "PAIR",                /* name */
 363          true,                  /* partial_inplace */
 364          0xffffffff,            /* src_mask */
 365          0xffffffff,            /* dst_mask */
 366          false),                /* pcrel_offset */
 367 };
 368
 369 /* Turn a howto into a reloc  nunmber */
 370
 371 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 372 #define BADMAG(x) MIPSBADMAG(x)
 373 #define MIPS 1                  /* Customize coffcode.h */
 374
 375 #define RTYPE2HOWTO(cache_ptr, dst) \
 376             (cache_ptr)->howto = howto_table + (dst)->r_type;
 377
 378 /* Compute the addend of a reloc.  If the reloc is to a common symbol,
 379    the object file contains the value of the common symbol.  By the
 380    time this is called, the linker may be using a different symbol
 381    from a different object file with a different value.  Therefore, we
 382    hack wildly to locate the original symbol from this file so that we
 383    can make the correct adjustment.  This macro sets coffsym to the
 384    symbol from the original file, and uses it to set the addend value
 385    correctly.  If this is not a common symbol, the usual addend
 386    calculation is done, except that an additional tweak is needed for
 387    PC relative relocs.
 388    FIXME: This macro refers to symbols and asect; these are from the
 389    calling function, not the macro arguments.  */
 390
 391 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
 392   {                                                             \
 393     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
 394     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
 395       coffsym = (obj_symbols (abfd)                             \
 396                  + (cache_ptr->sym_ptr_ptr - symbols));         \
 397     else if (ptr)                                               \
 398       coffsym = coff_symbol_from (abfd, ptr);                   \
 399     if (coffsym != (coff_symbol_type *) NULL                    \
 400         && coffsym->native->u.syment.n_scnum == 0)              \
 401       cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
 402     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
 403              && ptr->section != (asection *) NULL)              \
 404       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
 405     else                                                        \
 406       cache_ptr->addend = 0;                                    \
 407     if (ptr && howto_table[reloc.r_type].pc_relative)           \
 408       cache_ptr->addend += asect->vma;                          \
 409   }
 410
 411
 412 /* Convert an rtype to howto for the COFF backend linker.  */
 413
 414 static reloc_howto_type *
 415 coff_mips_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 416      bfd *abfd ATTRIBUTE_UNUSED;
 417      asection *sec;
 418      struct internal_reloc *rel;
 419      struct coff_link_hash_entry *h;
 420      struct internal_syment *sym;
 421      bfd_vma *addendp;
 422 {
 423
 424   reloc_howto_type *howto;
 425
 426   howto = howto_table + rel->r_type;
 427
 428 #ifdef COFF_WITH_PE
 429   *addendp = 0;
 430 #endif
 431
 432   if (howto->pc_relative)
 433     *addendp += sec->vma;
 434
 435   if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
 436     {
 437       /* This is a common symbol.  The section contents include the
 438          size (sym->n_value) as an addend.  The relocate_section
 439          function will be adding in the final value of the symbol.  We
 440          need to subtract out the current size in order to get the
 441          correct result.  */
 442
 443       BFD_ASSERT (h != NULL);
 444
 445 #ifndef COFF_WITH_PE
 446       /* I think we *do* want to bypass this.  If we don't, I have
 447          seen some data parameters get the wrong relocation address.
 448          If I link two versions with and without this section bypassed
 449          and then do a binary comparison, the addresses which are
 450          different can be looked up in the map.  The case in which
 451          this section has been bypassed has addresses which correspond
 452          to values I can find in the map.  */
 453       *addendp -= sym->n_value;
 454 #endif
 455     }
 456
 457 #ifndef COFF_WITH_PE
 458   /* If the output symbol is common (in which case this must be a
 459      relocateable link), we need to add in the final size of the
 460      common symbol.  */
 461   if (h != NULL && h->root.type == bfd_link_hash_common)
 462     *addendp += h->root.u.c.size;
 463 #endif
 464
 465 #ifdef COFF_WITH_PE
 466   if (howto->pc_relative)
 467     {
 468       *addendp -= 4;
 469
 470       /* If the symbol is defined, then the generic code is going to
 471          add back the symbol value in order to cancel out an
 472          adjustment it made to the addend.  However, we set the addend
 473          to 0 at the start of this function.  We need to adjust here,
 474          to avoid the adjustment the generic code will make.  FIXME:
 475          This is getting a bit hackish.  */
 476       if (sym != NULL && sym->n_scnum != 0)
 477         *addendp -= sym->n_value;
 478     }
 479
 480   if (rel->r_type == MIPS_R_RVA)
 481     {
 482       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
 483     }
 484 #endif
 485
 486   return howto;
 487 }
 488
 489 #define coff_rtype_to_howto coff_mips_rtype_to_howto
 490
 491
 492 #define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
 493
 494
 495
 496 /* Get the howto structure for a generic reloc type.  */
 497
 498 static reloc_howto_type *
 499 coff_mips_reloc_type_lookup (abfd, code)
 500      bfd *abfd ATTRIBUTE_UNUSED;
 501      bfd_reloc_code_real_type code;
 502 {
 503   int mips_type;
 504
 505   switch (code)
 506     {
 507     case BFD_RELOC_16:
 508       mips_type = MIPS_R_REFHALF;
 509       break;
 510     case BFD_RELOC_32:
 511     case BFD_RELOC_CTOR:
 512       mips_type = MIPS_R_REFWORD;
 513       break;
 514     case BFD_RELOC_MIPS_JMP:
 515       mips_type = MIPS_R_JMPADDR;
 516       break;
 517     case BFD_RELOC_HI16_S:
 518       mips_type = MIPS_R_REFHI;
 519       break;
 520     case BFD_RELOC_LO16:
 521       mips_type = MIPS_R_REFLO;
 522       break;
 523     case BFD_RELOC_MIPS_GPREL:
 524       mips_type = MIPS_R_GPREL;
 525       break;
 526     case BFD_RELOC_MIPS_LITERAL:
 527       mips_type = MIPS_R_LITERAL;
 528       break;
 529 /* FIXME?
 530     case BFD_RELOC_16_PCREL_S2:
 531       mips_type = MIPS_R_PCREL16;
 532       break;
 533     case BFD_RELOC_PCREL_HI16_S:
 534       mips_type = MIPS_R_RELHI;
 535       break;
 536     case BFD_RELOC_PCREL_LO16:
 537       mips_type = MIPS_R_RELLO;
 538       break;
 539     case BFD_RELOC_GPREL32:
 540       mips_type = MIPS_R_SWITCH;
 541       break;
 542 */
 543     case BFD_RELOC_RVA:
 544       mips_type = MIPS_R_RVA;
 545       break;
 546     default:
 547       return (reloc_howto_type *) NULL;
 548     }
 549
 550   return &howto_table[mips_type];
 551 }
 552
 553 static void
 554 mips_swap_reloc_in (abfd, src, dst)
 555      bfd *abfd;
 556      PTR src;
 557      PTR dst;
 558 {
 559   static struct internal_reloc pair_prev;
 560   RELOC *reloc_src = (RELOC *) src;
 561   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
 562
 563   reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
 564   reloc_dst->r_symndx =
 565     bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
 566   reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
 567   reloc_dst->r_size = 0;
 568   reloc_dst->r_extern = 0;
 569   reloc_dst->r_offset = 0;
 570
 571   switch (reloc_dst->r_type)
 572   {
 573   case MIPS_R_REFHI:
 574     pair_prev = *reloc_dst;
 575     break;
 576   case MIPS_R_PAIR:
 577     reloc_dst->r_offset = reloc_dst->r_symndx;
 578     if (reloc_dst->r_offset & 0x8000)
 579       reloc_dst->r_offset -= 0x10000;
 580     /*printf("dj: pair offset is %08x\n", reloc_dst->r_offset);*/
 581     reloc_dst->r_symndx = pair_prev.r_symndx;
 582     break;
 583   }
 584 }
 585
 586 static unsigned int
 587 mips_swap_reloc_out (abfd, src, dst)
 588      bfd       *abfd;
 589      PTR        src;
 590      PTR        dst;
 591 {
 592   static int prev_offset = 1;
 593   static bfd_vma prev_addr = 0;
 594   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
 595   struct external_reloc *reloc_dst = (struct external_reloc *)dst;
 596
 597   switch (reloc_src->r_type)
 598     {
 599     case MIPS_R_REFHI:
 600       prev_addr = reloc_src->r_vaddr;
 601       prev_offset = reloc_src->r_offset;
 602       break;
 603     case MIPS_R_REFLO:
 604       if (reloc_src->r_vaddr == prev_addr)
 605         {
 606           /* FIXME: only slightly hackish.  If we see a REFLO pointing to
 607              the same address as a REFHI, we assume this is the matching
 608              PAIR reloc and output it accordingly.  The symndx is really
 609              the low 16 bits of the addend */
 610           bfd_h_put_32 (abfd, reloc_src->r_vaddr,
 611                         (bfd_byte *) reloc_dst->r_vaddr);
 612           bfd_h_put_32 (abfd, reloc_src->r_symndx,
 613                         (bfd_byte *) reloc_dst->r_symndx);
 614
 615           bfd_h_put_16(abfd, MIPS_R_PAIR, (bfd_byte *)
 616                        reloc_dst->r_type);
 617           return RELSZ;
 618         }
 619       break;
 620     }
 621
 622   bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
 623   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
 624
 625   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
 626                reloc_dst->r_type);
 627   return RELSZ;
 628 }
 629
 630 #define coff_swap_reloc_in mips_swap_reloc_in
 631 #define coff_swap_reloc_out mips_swap_reloc_out
 632 #define NO_COFF_RELOCS
 633
 634 static boolean
 635 coff_pe_mips_relocate_section (output_bfd, info, input_bfd,
 636                                input_section, contents, relocs, syms,
 637                                sections)
 638      bfd *output_bfd;
 639      struct bfd_link_info *info;
 640      bfd *input_bfd;
 641      asection *input_section;
 642      bfd_byte *contents;
 643      struct internal_reloc *relocs;
 644      struct internal_syment *syms;
 645      asection **sections;
 646 {
 647   bfd_vma gp;
 648   boolean gp_undefined;
 649   size_t adjust;
 650   struct internal_reloc *rel;
 651   struct internal_reloc *rel_end;
 652   unsigned int i;
 653   boolean got_lo;
 654
 655   if (info->relocateable)
 656   {
 657     (*_bfd_error_handler)(_("\
 658 %s: `ld -r' not supported with PE MIPS objects\n"),
 659                           bfd_get_filename (input_bfd));
 660     bfd_set_error (bfd_error_bad_value);
 661     return false;
 662   }
 663
 664   BFD_ASSERT (input_bfd->xvec->byteorder
 665               == output_bfd->xvec->byteorder);
 666
 667 #if 0
 668   printf("dj: relocate %s(%s) %08x\n",
 669          input_bfd->filename, input_section->name,
 670          input_section->output_section->vma + input_section->output_offset);
 671 #endif
 672
 673   gp = _bfd_get_gp_value (output_bfd);
 674   if (gp == 0)
 675     gp_undefined = true;
 676   else
 677     gp_undefined = false;
 678
 679   got_lo = false;
 680
 681   adjust = 0;
 682
 683   rel = relocs;
 684   rel_end = rel + input_section->reloc_count;
 685   for (i = 0; rel < rel_end; rel++, i++)
 686     {
 687       long symndx;
 688       struct coff_link_hash_entry *h;
 689       struct internal_syment *sym;
 690       bfd_vma addend = 0;
 691       bfd_vma val, tmp, targ, src, low;
 692       reloc_howto_type *howto;
 693       unsigned char *mem = contents + rel->r_vaddr;
 694
 695       symndx = rel->r_symndx;
 696
 697       if (symndx == -1)
 698         {
 699           h = NULL;
 700           sym = NULL;
 701         }
 702       else
 703         {
 704           h = obj_coff_sym_hashes (input_bfd)[symndx];
 705           sym = syms + symndx;
 706         }
 707
 708       /* COFF treats common symbols in one of two ways.  Either the
 709          size of the symbol is included in the section contents, or it
 710          is not.  We assume that the size is not included, and force
 711          the rtype_to_howto function to adjust the addend as needed.  */
 712
 713       if (sym != NULL && sym->n_scnum != 0)
 714         addend = - sym->n_value;
 715       else
 716         addend = 0;
 717
 718
 719       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
 720                                        sym, &addend);
 721       if (howto == NULL)
 722         return false;
 723
 724       /* If we are doing a relocateable link, then we can just ignore
 725          a PC relative reloc that is pcrel_offset.  It will already
 726          have the correct value.  If this is not a relocateable link,
 727          then we should ignore the symbol value.  */
 728       if (howto->pc_relative && howto->pcrel_offset)
 729         {
 730           if (info->relocateable)
 731             continue;
 732           if (sym != NULL && sym->n_scnum != 0)
 733             addend += sym->n_value;
 734         }
 735
 736       val = 0;
 737
 738       if (h == NULL)
 739         {
 740           asection *sec;
 741
 742           if (symndx == -1)
 743             {
 744               sec = bfd_abs_section_ptr;
 745               val = 0;
 746             }
 747           else
 748             {
 749               sec = sections[symndx];
 750               val = (sec->output_section->vma
 751                      + sec->output_offset
 752                      + sym->n_value);
 753               if (! obj_pe (input_bfd))
 754                 val -= sec->vma;
 755             }
 756         }
 757       else
 758         {
 759           if (h->root.type == bfd_link_hash_defined
 760               || h->root.type == bfd_link_hash_defweak)
 761             {
 762               asection *sec;
 763
 764               sec = h->root.u.def.section;
 765               val = (h->root.u.def.value
 766                      + sec->output_section->vma
 767                      + sec->output_offset);
 768               }
 769
 770           else if (! info->relocateable)
 771             {
 772               if (! ((*info->callbacks->undefined_symbol)
 773                      (info, h->root.root.string, input_bfd, input_section,
 774                       rel->r_vaddr - input_section->vma, true)))
 775                 return false;
 776             }
 777         }
 778
 779       src = rel->r_vaddr + input_section->output_section->vma
 780         + input_section->output_offset;
 781 #if 0
 782       printf("dj: reloc %02x %-8s a=%08x/%08x(%08x) v=%08x+%08x %s\n",
 783              rel->r_type, howto_table[rel->r_type].name,
 784              src, rel->r_vaddr, *(unsigned long *)mem, val, rel->r_offset,
 785              h?h->root.root.string:"(none)");
 786 #endif
 787
 788       /* OK, at this point the following variables are set up:
 789            src = VMA of the memory we're fixing up
 790            mem = pointer to memory we're fixing up
 791            val = VMA of what we need to refer to
 792       */
 793
 794 #define UI(x) (*_bfd_error_handler)(_("%s: unimplemented %s\n"), \
 795                                     bfd_get_filename (input_bfd), x); \
 796               bfd_set_error (bfd_error_bad_value);
 797
 798       switch (rel->r_type)
 799         {
 800         case MIPS_R_ABSOLUTE:
 801           /* ignore these */
 802           break;
 803
 804         case MIPS_R_REFHALF:
 805           UI("refhalf");
 806           break;
 807
 808         case MIPS_R_REFWORD:
 809           tmp = bfd_get_32(input_bfd, mem);
 810           /* printf("refword: src=%08x targ=%08x+%08x\n", src, tmp, val); */
 811           tmp += val;
 812           bfd_put_32(input_bfd, tmp, mem);
 813           break;
 814
 815         case MIPS_R_JMPADDR:
 816           tmp = bfd_get_32(input_bfd, mem);
 817           targ = val + (tmp&0x03ffffff)*4;
 818           if ((src & 0xf0000000) != (targ & 0xf0000000))
 819             {
 820               (*_bfd_error_handler)(_("%s: jump too far away\n"),
 821                                     bfd_get_filename (input_bfd));
 822               bfd_set_error (bfd_error_bad_value);
 823               return false;
 824             }
 825           tmp &= 0xfc000000;
 826           tmp |= (targ/4) & 0x3ffffff;
 827           bfd_put_32(input_bfd, tmp, mem);
 828           break;
 829
 830         case MIPS_R_REFHI:
 831           tmp = bfd_get_32(input_bfd, mem);
 832           switch (rel[1].r_type)
 833             {
 834             case MIPS_R_PAIR:
 835               /* MS PE object */
 836               targ = val + rel[1].r_offset + ((tmp & 0xffff) << 16);
 837               break;
 838             case MIPS_R_REFLO:
 839               /* GNU COFF object */
 840               low = bfd_get_32(input_bfd, contents + rel[1].r_vaddr);
 841               low &= 0xffff;
 842               if (low & 0x8000)
 843                 low -= 0x10000;
 844               targ = val + low + ((tmp & 0xffff) << 16);
 845               break;
 846             default:
 847               (*_bfd_error_handler)(_("%s: bad pair/reflo after refhi\n"),
 848                                     bfd_get_filename (input_bfd));
 849               bfd_set_error (bfd_error_bad_value);
 850               return false;
 851             }
 852           tmp &= 0xffff0000;
 853           tmp |= (targ >> 16) & 0xffff;
 854           bfd_put_32(input_bfd, tmp, mem);
 855           break;
 856
 857         case MIPS_R_REFLO:
 858           tmp = bfd_get_32(input_bfd, mem);
 859           targ = val + (tmp & 0xffff);
 860           /* printf("refword: src=%08x targ=%08x\n", src, targ); */
 861           tmp &= 0xffff0000;
 862           tmp |= targ & 0xffff;
 863           bfd_put_32(input_bfd, tmp, mem);
 864           break;
 865
 866         case MIPS_R_GPREL:
 867         case MIPS_R_LITERAL:
 868           UI("gprel");
 869           break;
 870
 871         case MIPS_R_SECTION:
 872           UI("section");
 873           break;
 874
 875         case MIPS_R_SECREL:
 876           UI("secrel");
 877           break;
 878
 879         case MIPS_R_SECRELLO:
 880           UI("secrello");
 881           break;
 882
 883         case MIPS_R_SECRELHI:
 884           UI("secrelhi");
 885           break;
 886
 887         case MIPS_R_RVA:
 888           tmp = bfd_get_32 (input_bfd, mem);
 889           /* printf("rva: src=%08x targ=%08x+%08x\n", src, tmp, val); */
 890           tmp += val
 891             - pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
 892           bfd_put_32 (input_bfd, tmp, mem);
 893           break;
 894
 895         case MIPS_R_PAIR:
 896           /* ignore these */
 897           break;
 898         }
 899     }
 900
 901   return true;
 902 }
 903
 904 #define coff_relocate_section coff_pe_mips_relocate_section
 905
 906 #ifdef TARGET_UNDERSCORE
 907
 908 /* If mips gcc uses underscores for symbol names, then it does not use
 909    a leading dot for local labels, so if TARGET_UNDERSCORE is defined
 910    we treat all symbols starting with L as local.  */
 911
 912 static boolean coff_mips_is_local_label_name PARAMS ((bfd *, const char *));
 913
 914 static boolean
 915 coff_mips_is_local_label_name (abfd, name)
 916      bfd *abfd;
 917      const char *name;
 918 {
 919   if (name[0] == 'L')
 920     return true;
 921
 922   return _bfd_coff_is_local_label_name (abfd, name);
 923 }
 924
 925 #define coff_bfd_is_local_label_name coff_mips_is_local_label_name
 926
 927 #endif /* TARGET_UNDERSCORE */
 928
 929 #define COFF_NO_HACK_SCNHDR_SIZE
 930
 931 #include "coffcode.h"
 932
 933 const bfd_target
 934 #ifdef TARGET_SYM
 935   TARGET_SYM =
 936 #else
 937   mipslpe_vec =
 938 #endif
 939 {
 940 #ifdef TARGET_NAME
 941   TARGET_NAME,
 942 #else
 943   "pe-mips",                    /* name */
 944 #endif
 945   bfd_target_coff_flavour,
 946   BFD_ENDIAN_LITTLE,            /* data byte order is little */
 947   BFD_ENDIAN_LITTLE,            /* header byte order is little */
 948
 949   (HAS_RELOC | EXEC_P |         /* object flags */
 950    HAS_LINENO | HAS_DEBUG |
 951    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 952
 953 #ifndef COFF_WITH_PE
 954   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 955    | SEC_CODE | SEC_DATA),
 956 #else
 957   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
 958    | SEC_CODE | SEC_DATA
 959    | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
 960 #endif
 961
 962 #ifdef TARGET_UNDERSCORE
 963   TARGET_UNDERSCORE,            /* leading underscore */
 964 #else
 965   0,                            /* leading underscore */
 966 #endif
 967   '/',                          /* ar_pad_char */
 968   15,                           /* ar_max_namelen */
 969
 970   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 971      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 972      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 973   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 974      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 975      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 976
 977 /* Note that we allow an object file to be treated as a core file as well. */
 978     {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
 979        bfd_generic_archive_p, coff_object_p},
 980     {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
 981        bfd_false},
 982     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
 983        _bfd_write_archive_contents, bfd_false},
 984
 985      BFD_JUMP_TABLE_GENERIC (coff),
 986      BFD_JUMP_TABLE_COPY (coff),
 987      BFD_JUMP_TABLE_CORE (_bfd_nocore),
 988      BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 989      BFD_JUMP_TABLE_SYMBOLS (coff),
 990      BFD_JUMP_TABLE_RELOCS (coff),
 991      BFD_JUMP_TABLE_WRITE (coff),
 992      BFD_JUMP_TABLE_LINK (coff),
 993      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 994
 995   NULL,
 996
 997   COFF_SWAP_TABLE
 998 };