bfd/coff-alpha.c

   1 /* BFD back-end for ALPHA Extended-Coff files.
   2    Copyright 1993, 1994 Free Software Foundation, Inc.
   3    Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
   4    Ian Lance Taylor <ian@cygnus.com>.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "coff/internal.h"
  27 #include "coff/sym.h"
  28 #include "coff/symconst.h"
  29 #include "coff/ecoff.h"
  30 #include "coff/alpha.h"
  31 #include "libcoff.h"
  32 #include "libecoff.h"
  33 \f
  34 /* Prototypes for static functions.  */
  35
  36 static const bfd_target *alpha_ecoff_object_p PARAMS ((bfd *));
  37 static boolean alpha_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
  38 static PTR alpha_ecoff_mkobject_hook PARAMS ((bfd *, PTR filehdr, PTR aouthdr));
  39 static void alpha_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
  40                                               struct internal_reloc *));
  41 static void alpha_ecoff_swap_reloc_out PARAMS ((bfd *,
  42                                                const struct internal_reloc *,
  43                                                PTR));
  44 static void alpha_adjust_reloc_in PARAMS ((bfd *,
  45                                            const struct internal_reloc *,
  46                                            arelent *));
  47 static void alpha_adjust_reloc_out PARAMS ((bfd *, const arelent *,
  48                                             struct internal_reloc *));
  49 static bfd_byte *alpha_ecoff_get_relocated_section_contents
  50   PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *,
  51            bfd_byte *data, boolean relocateable, asymbol **symbols));
  52 static bfd_vma alpha_convert_external_reloc
  53   PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *,
  54            struct ecoff_link_hash_entry *));
  55 static boolean alpha_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
  56                                                bfd *, asection *,
  57                                                bfd_byte *, PTR));
  58 static boolean alpha_adjust_headers
  59   PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *));
  60 \f
  61 /* ECOFF has COFF sections, but the debugging information is stored in
  62    a completely different format.  ECOFF targets use some of the
  63    swapping routines from coffswap.h, and some of the generic COFF
  64    routines in coffgen.c, but, unlike the real COFF targets, do not
  65    use coffcode.h itself.
  66
  67    Get the generic COFF swapping routines, except for the reloc,
  68    symbol, and lineno ones.  Give them ecoff names.  Define some
  69    accessor macros for the large sizes used for Alpha ECOFF.  */
  70
  71 #define GET_FILEHDR_SYMPTR bfd_h_get_64
  72 #define PUT_FILEHDR_SYMPTR bfd_h_put_64
  73 #define GET_AOUTHDR_TSIZE bfd_h_get_64
  74 #define PUT_AOUTHDR_TSIZE bfd_h_put_64
  75 #define GET_AOUTHDR_DSIZE bfd_h_get_64
  76 #define PUT_AOUTHDR_DSIZE bfd_h_put_64
  77 #define GET_AOUTHDR_BSIZE bfd_h_get_64
  78 #define PUT_AOUTHDR_BSIZE bfd_h_put_64
  79 #define GET_AOUTHDR_ENTRY bfd_h_get_64
  80 #define PUT_AOUTHDR_ENTRY bfd_h_put_64
  81 #define GET_AOUTHDR_TEXT_START bfd_h_get_64
  82 #define PUT_AOUTHDR_TEXT_START bfd_h_put_64
  83 #define GET_AOUTHDR_DATA_START bfd_h_get_64
  84 #define PUT_AOUTHDR_DATA_START bfd_h_put_64
  85 #define GET_SCNHDR_PADDR bfd_h_get_64
  86 #define PUT_SCNHDR_PADDR bfd_h_put_64
  87 #define GET_SCNHDR_VADDR bfd_h_get_64
  88 #define PUT_SCNHDR_VADDR bfd_h_put_64
  89 #define GET_SCNHDR_SIZE bfd_h_get_64
  90 #define PUT_SCNHDR_SIZE bfd_h_put_64
  91 #define GET_SCNHDR_SCNPTR bfd_h_get_64
  92 #define PUT_SCNHDR_SCNPTR bfd_h_put_64
  93 #define GET_SCNHDR_RELPTR bfd_h_get_64
  94 #define PUT_SCNHDR_RELPTR bfd_h_put_64
  95 #define GET_SCNHDR_LNNOPTR bfd_h_get_64
  96 #define PUT_SCNHDR_LNNOPTR bfd_h_put_64
  97
  98 #define ALPHAECOFF
  99
 100 #define NO_COFF_RELOCS
 101 #define NO_COFF_SYMBOLS
 102 #define NO_COFF_LINENOS
 103 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
 104 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
 105 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
 106 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
 107 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
 108 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
 109 #include "coffswap.h"
 110
 111 /* Get the ECOFF swapping routines.  */
 112 #define ECOFF_64
 113 #include "ecoffswap.h"
 114 \f
 115 /* How to process the various reloc types.  */
 116
 117 static bfd_reloc_status_type
 118 reloc_nil PARAMS ((bfd *, arelent *, asymbol *, PTR,
 119                    asection *, bfd *, char **));
 120
 121 static bfd_reloc_status_type
 122 reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
 123      bfd *abfd;
 124      arelent *reloc;
 125      asymbol *sym;
 126      PTR data;
 127      asection *sec;
 128      bfd *output_bfd;
 129      char **error_message;
 130 {
 131   return bfd_reloc_ok;
 132 }
 133
 134 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 135    from smaller values.  Start with zero, widen, *then* decrement.  */
 136 #define MINUS_ONE       (((bfd_vma)0) - 1)
 137
 138 static reloc_howto_type alpha_howto_table[] =
 139 {
 140   /* Reloc type 0 is ignored by itself.  However, it appears after a
 141      GPDISP reloc to identify the location where the low order 16 bits
 142      of the gp register are loaded.  */
 143   HOWTO (ALPHA_R_IGNORE,        /* type */
 144          0,                     /* rightshift */
 145          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 146          8,                     /* bitsize */
 147          true,                  /* pc_relative */
 148          0,                     /* bitpos */
 149          complain_overflow_dont, /* complain_on_overflow */
 150          reloc_nil,             /* special_function */
 151          "IGNORE",              /* name */
 152          true,                  /* partial_inplace */
 153          0,                     /* src_mask */
 154          0,                     /* dst_mask */
 155          true),                 /* pcrel_offset */
 156
 157   /* A 32 bit reference to a symbol.  */
 158   HOWTO (ALPHA_R_REFLONG,       /* type */
 159          0,                     /* rightshift */
 160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 161          32,                    /* bitsize */
 162          false,                 /* pc_relative */
 163          0,                     /* bitpos */
 164          complain_overflow_bitfield, /* complain_on_overflow */
 165          0,                     /* special_function */
 166          "REFLONG",             /* name */
 167          true,                  /* partial_inplace */
 168          0xffffffff,            /* src_mask */
 169          0xffffffff,            /* dst_mask */
 170          false),                /* pcrel_offset */
 171
 172   /* A 64 bit reference to a symbol.  */
 173   HOWTO (ALPHA_R_REFQUAD,       /* type */
 174          0,                     /* rightshift */
 175          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 176          64,                    /* bitsize */
 177          false,                 /* pc_relative */
 178          0,                     /* bitpos */
 179          complain_overflow_bitfield, /* complain_on_overflow */
 180          0,                     /* special_function */
 181          "REFQUAD",             /* name */
 182          true,                  /* partial_inplace */
 183          MINUS_ONE,             /* src_mask */
 184          MINUS_ONE,             /* dst_mask */
 185          false),                /* pcrel_offset */
 186
 187   /* A 32 bit GP relative offset.  This is just like REFLONG except
 188      that when the value is used the value of the gp register will be
 189      added in.  */
 190   HOWTO (ALPHA_R_GPREL32,       /* type */
 191          0,                     /* rightshift */
 192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 193          32,                    /* bitsize */
 194          false,                 /* pc_relative */
 195          0,                     /* bitpos */
 196          complain_overflow_bitfield, /* complain_on_overflow */
 197          0,                     /* special_function */
 198          "GPREL32",             /* name */
 199          true,                  /* partial_inplace */
 200          0xffffffff,            /* src_mask */
 201          0xffffffff,            /* dst_mask */
 202          false),                /* pcrel_offset */
 203
 204   /* Used for an instruction that refers to memory off the GP
 205      register.  The offset is 16 bits of the 32 bit instruction.  This
 206      reloc always seems to be against the .lita section.  */
 207   HOWTO (ALPHA_R_LITERAL,       /* type */
 208          0,                     /* rightshift */
 209          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 210          16,                    /* bitsize */
 211          false,                 /* pc_relative */
 212          0,                     /* bitpos */
 213          complain_overflow_signed, /* complain_on_overflow */
 214          0,                     /* special_function */
 215          "LITERAL",             /* name */
 216          true,                  /* partial_inplace */
 217          0xffff,                /* src_mask */
 218          0xffff,                /* dst_mask */
 219          false),                /* pcrel_offset */
 220
 221   /* This reloc only appears immediately following a LITERAL reloc.
 222      It identifies a use of the literal.  It seems that the linker can
 223      use this to eliminate a portion of the .lita section.  The symbol
 224      index is special: 1 means the literal address is in the base
 225      register of a memory format instruction; 2 means the literal
 226      address is in the byte offset register of a byte-manipulation
 227      instruction; 3 means the literal address is in the target
 228      register of a jsr instruction.  This does not actually do any
 229      relocation.  */
 230   HOWTO (ALPHA_R_LITUSE,        /* type */
 231          0,                     /* rightshift */
 232          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 233          32,                    /* bitsize */
 234          false,                 /* pc_relative */
 235          0,                     /* bitpos */
 236          complain_overflow_dont, /* complain_on_overflow */
 237          reloc_nil,             /* special_function */
 238          "LITUSE",              /* name */
 239          false,                 /* partial_inplace */
 240          0,                     /* src_mask */
 241          0,                     /* dst_mask */
 242          false),                /* pcrel_offset */
 243
 244   /* Load the gp register.  This is always used for a ldah instruction
 245      which loads the upper 16 bits of the gp register.  The next reloc
 246      will be an IGNORE reloc which identifies the location of the lda
 247      instruction which loads the lower 16 bits.  The symbol index of
 248      the GPDISP instruction appears to actually be the number of bytes
 249      between the ldah and lda instructions.  This gives two different
 250      ways to determine where the lda instruction is; I don't know why
 251      both are used.  The value to use for the relocation is the
 252      difference between the GP value and the current location; the
 253      load will always be done against a register holding the current
 254      address.  */
 255   HOWTO (ALPHA_R_GPDISP,        /* type */
 256          16,                    /* rightshift */
 257          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 258          16,                    /* bitsize */
 259          true,                  /* pc_relative */
 260          0,                     /* bitpos */
 261          complain_overflow_dont, /* complain_on_overflow */
 262          reloc_nil,             /* special_function */
 263          "GPDISP",              /* name */
 264          true,                  /* partial_inplace */
 265          0xffff,                /* src_mask */
 266          0xffff,                /* dst_mask */
 267          true),                 /* pcrel_offset */
 268
 269   /* A 21 bit branch.  The native assembler generates these for
 270      branches within the text segment, and also fills in the PC
 271      relative offset in the instruction.  */
 272   HOWTO (ALPHA_R_BRADDR,        /* type */
 273          2,                     /* rightshift */
 274          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          21,                    /* bitsize */
 276          true,                  /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_signed, /* complain_on_overflow */
 279          0,                     /* special_function */
 280          "BRADDR",              /* name */
 281          true,                  /* partial_inplace */
 282          0x1fffff,              /* src_mask */
 283          0x1fffff,              /* dst_mask */
 284          false),                /* pcrel_offset */
 285
 286   /* A hint for a jump to a register.  */
 287   HOWTO (ALPHA_R_HINT,          /* type */
 288          2,                     /* rightshift */
 289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          14,                    /* bitsize */
 291          true,                  /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_dont, /* complain_on_overflow */
 294          0,                     /* special_function */
 295          "HINT",                /* name */
 296          true,                  /* partial_inplace */
 297          0x3fff,                /* src_mask */
 298          0x3fff,                /* dst_mask */
 299          false),                /* pcrel_offset */
 300
 301   /* 16 bit PC relative offset.  */
 302   HOWTO (ALPHA_R_SREL16,        /* type */
 303          0,                     /* rightshift */
 304          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 305          16,                    /* bitsize */
 306          true,                  /* pc_relative */
 307          0,                     /* bitpos */
 308          complain_overflow_signed, /* complain_on_overflow */
 309          0,                     /* special_function */
 310          "SREL16",              /* name */
 311          true,                  /* partial_inplace */
 312          0xffff,                /* src_mask */
 313          0xffff,                /* dst_mask */
 314          false),                /* pcrel_offset */
 315
 316   /* 32 bit PC relative offset.  */
 317   HOWTO (ALPHA_R_SREL32,        /* type */
 318          0,                     /* rightshift */
 319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 320          32,                    /* bitsize */
 321          true,                  /* pc_relative */
 322          0,                     /* bitpos */
 323          complain_overflow_signed, /* complain_on_overflow */
 324          0,                     /* special_function */
 325          "SREL32",              /* name */
 326          true,                  /* partial_inplace */
 327          0xffffffff,            /* src_mask */
 328          0xffffffff,            /* dst_mask */
 329          false),                /* pcrel_offset */
 330
 331   /* A 64 bit PC relative offset.  */
 332   HOWTO (ALPHA_R_SREL64,        /* type */
 333          0,                     /* rightshift */
 334          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 335          64,                    /* bitsize */
 336          true,                  /* pc_relative */
 337          0,                     /* bitpos */
 338          complain_overflow_signed, /* complain_on_overflow */
 339          0,                     /* special_function */
 340          "SREL64",              /* name */
 341          true,                  /* partial_inplace */
 342          MINUS_ONE,             /* src_mask */
 343          MINUS_ONE,             /* dst_mask */
 344          false),                /* pcrel_offset */
 345
 346   /* Push a value on the reloc evaluation stack.  */
 347   HOWTO (ALPHA_R_OP_PUSH,       /* type */
 348          0,                     /* rightshift */
 349          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          0,                     /* bitsize */
 351          false,                 /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_dont, /* complain_on_overflow */
 354          0,                     /* special_function */
 355          "OP_PUSH",             /* name */
 356          false,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0,                     /* dst_mask */
 359          false),                /* pcrel_offset */
 360
 361   /* Store the value from the stack at the given address.  Store it in
 362      a bitfield of size r_size starting at bit position r_offset.  */
 363   HOWTO (ALPHA_R_OP_STORE,      /* type */
 364          0,                     /* rightshift */
 365          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 366          64,                    /* bitsize */
 367          false,                 /* pc_relative */
 368          0,                     /* bitpos */
 369          complain_overflow_dont, /* complain_on_overflow */
 370          0,                     /* special_function */
 371          "OP_STORE",            /* name */
 372          false,                 /* partial_inplace */
 373          0,                     /* src_mask */
 374          MINUS_ONE,             /* dst_mask */
 375          false),                /* pcrel_offset */
 376
 377   /* Subtract the reloc address from the value on the top of the
 378      relocation stack.  */
 379   HOWTO (ALPHA_R_OP_PSUB,       /* type */
 380          0,                     /* rightshift */
 381          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          0,                     /* bitsize */
 383          false,                 /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_dont, /* complain_on_overflow */
 386          0,                     /* special_function */
 387          "OP_PSUB",             /* name */
 388          false,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0,                     /* dst_mask */
 391          false),                /* pcrel_offset */
 392
 393   /* Shift the value on the top of the relocation stack right by the
 394      given value.  */
 395   HOWTO (ALPHA_R_OP_PRSHIFT,    /* type */
 396          0,                     /* rightshift */
 397          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 398          0,                     /* bitsize */
 399          false,                 /* pc_relative */
 400          0,                     /* bitpos */
 401          complain_overflow_dont, /* complain_on_overflow */
 402          0,                     /* special_function */
 403          "OP_PRSHIFT",          /* name */
 404          false,                 /* partial_inplace */
 405          0,                     /* src_mask */
 406          0,                     /* dst_mask */
 407          false),                /* pcrel_offset */
 408
 409   /* Adjust the GP value for a new range in the object file.  */
 410   HOWTO (ALPHA_R_GPVALUE,       /* type */
 411          0,                     /* rightshift */
 412          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 413          0,                     /* bitsize */
 414          false,                 /* pc_relative */
 415          0,                     /* bitpos */
 416          complain_overflow_dont, /* complain_on_overflow */
 417          0,                     /* special_function */
 418          "GPVALUE",             /* name */
 419          false,                 /* partial_inplace */
 420          0,                     /* src_mask */
 421          0,                     /* dst_mask */
 422          false)                 /* pcrel_offset */
 423 };
 424 \f
 425 /* Recognize an Alpha ECOFF file.  */
 426
 427 static const bfd_target *
 428 alpha_ecoff_object_p (abfd)
 429      bfd *abfd;
 430 {
 431   static const bfd_target *ret;
 432
 433   ret = coff_object_p (abfd);
 434
 435   if (ret != NULL)
 436     {
 437       asection *sec;
 438
 439       /* Alpha ECOFF has a .pdata section.  The lnnoptr field of the
 440          .pdata section is the number of entries it contains.  Each
 441          entry takes up 8 bytes.  The number of entries is required
 442          since the section is aligned to a 16 byte boundary.  When we
 443          link .pdata sections together, we do not want to include the
 444          alignment bytes.  We handle this on input by faking the size
 445          of the .pdata section to remove the unwanted alignment bytes.
 446          On output we will set the lnnoptr field and force the
 447          alignment.  */
 448       sec = bfd_get_section_by_name (abfd, _PDATA);
 449       if (sec != (asection *) NULL)
 450         {
 451           bfd_size_type size;
 452
 453           size = sec->line_filepos * 8;
 454           BFD_ASSERT (size == bfd_section_size (abfd, sec)
 455                       || size + 8 == bfd_section_size (abfd, sec));
 456           if (! bfd_set_section_size (abfd, sec, size))
 457             return NULL;
 458         }
 459     }
 460
 461   return ret;
 462 }
 463
 464 /* See whether the magic number matches.  */
 465
 466 static boolean
 467 alpha_ecoff_bad_format_hook (abfd, filehdr)
 468      bfd *abfd;
 469      PTR filehdr;
 470 {
 471   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 472
 473   if (ALPHA_ECOFF_BADMAG (*internal_f))
 474     return false;
 475
 476   return true;
 477 }
 478
 479 /* This is a hook called by coff_real_object_p to create any backend
 480    specific information.  */
 481
 482 static PTR
 483 alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
 484      bfd *abfd;
 485      PTR filehdr;
 486      PTR aouthdr;
 487 {
 488   PTR ecoff;
 489
 490   ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
 491
 492   if (ecoff != NULL)
 493     {
 494       struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 495
 496       /* Set additional BFD flags according to the object type from the
 497          machine specific file header flags.  */
 498       switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
 499         {
 500         case F_ALPHA_SHARABLE:
 501           abfd->flags |= DYNAMIC;
 502           break;
 503         case F_ALPHA_CALL_SHARED:
 504           /* Always executable if using shared libraries as the run time
 505              loader might resolve undefined references.  */
 506           abfd->flags |= (DYNAMIC | EXEC_P);
 507           break;
 508         }
 509     }
 510   return ecoff;
 511 }
 512 \f
 513 /* Reloc handling.  */
 514
 515 /* Swap a reloc in.  */
 516
 517 static void
 518 alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
 519      bfd *abfd;
 520      PTR ext_ptr;
 521      struct internal_reloc *intern;
 522 {
 523   const RELOC *ext = (RELOC *) ext_ptr;
 524
 525   intern->r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext->r_vaddr);
 526   intern->r_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_symndx);
 527
 528   BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
 529
 530   intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
 531                     >> RELOC_BITS0_TYPE_SH_LITTLE);
 532   intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
 533   intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
 534                       >> RELOC_BITS1_OFFSET_SH_LITTLE);
 535   /* Ignored the reserved bits.  */
 536   intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
 537                     >> RELOC_BITS3_SIZE_SH_LITTLE);
 538
 539   if (intern->r_type == ALPHA_R_LITUSE
 540       || intern->r_type == ALPHA_R_GPDISP)
 541     {
 542       /* Handle the LITUSE and GPDISP relocs specially.  Its symndx
 543          value is not actually a symbol index, but is instead a
 544          special code.  We put the code in the r_size field, and
 545          clobber the symndx.  */
 546       if (intern->r_size != 0)
 547         abort ();
 548       intern->r_size = intern->r_symndx;
 549       intern->r_symndx = RELOC_SECTION_NONE;
 550     }
 551   else if (intern->r_type == ALPHA_R_IGNORE)
 552     {
 553       /* The IGNORE reloc generally follows a GPDISP reloc, and is
 554          against the .lita section.  The section is irrelevant.  */
 555       if (! intern->r_extern &&
 556           intern->r_symndx == RELOC_SECTION_ABS)
 557         abort ();
 558       if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
 559         intern->r_symndx = RELOC_SECTION_ABS;
 560     }
 561 }
 562
 563 /* Swap a reloc out.  */
 564
 565 static void
 566 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
 567      bfd *abfd;
 568      const struct internal_reloc *intern;
 569      PTR dst;
 570 {
 571   RELOC *ext = (RELOC *) dst;
 572   long symndx;
 573   unsigned char size;
 574
 575   /* Undo the hackery done in swap_reloc_in.  */
 576   if (intern->r_type == ALPHA_R_LITUSE
 577       || intern->r_type == ALPHA_R_GPDISP)
 578     {
 579       symndx = intern->r_size;
 580       size = 0;
 581     }
 582   else if (intern->r_type == ALPHA_R_IGNORE
 583            && ! intern->r_extern
 584            && intern->r_symndx == RELOC_SECTION_ABS)
 585     {
 586       symndx = RELOC_SECTION_LITA;
 587       size = intern->r_size;
 588     }
 589   else
 590     {
 591       symndx = intern->r_symndx;
 592       size = intern->r_size;
 593     }
 594
 595   BFD_ASSERT (intern->r_extern
 596               || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
 597
 598   bfd_h_put_64 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
 599   bfd_h_put_32 (abfd, symndx, (bfd_byte *) ext->r_symndx);
 600
 601   BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
 602
 603   ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
 604                     & RELOC_BITS0_TYPE_LITTLE);
 605   ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
 606                     | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
 607                        & RELOC_BITS1_OFFSET_LITTLE));
 608   ext->r_bits[2] = 0;
 609   ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
 610                     & RELOC_BITS3_SIZE_LITTLE);
 611 }
 612
 613 /* Finish canonicalizing a reloc.  Part of this is generic to all
 614    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 615    this backend routine.  It must fill in the howto field.  */
 616
 617 static void
 618 alpha_adjust_reloc_in (abfd, intern, rptr)
 619      bfd *abfd;
 620      const struct internal_reloc *intern;
 621      arelent *rptr;
 622 {
 623   if (intern->r_type > ALPHA_R_GPVALUE)
 624     abort ();
 625
 626   switch (intern->r_type)
 627     {
 628     case ALPHA_R_BRADDR:
 629     case ALPHA_R_SREL16:
 630     case ALPHA_R_SREL32:
 631     case ALPHA_R_SREL64:
 632       /* The PC relative relocs do not seem to use the section VMA as
 633          a negative addend.  */
 634       rptr->addend = 0;
 635       break;
 636
 637     case ALPHA_R_GPREL32:
 638     case ALPHA_R_LITERAL:
 639       /* Copy the gp value for this object file into the addend, to
 640          ensure that we are not confused by the linker.  */
 641       if (! intern->r_extern)
 642         rptr->addend += ecoff_data (abfd)->gp;
 643       break;
 644
 645     case ALPHA_R_LITUSE:
 646     case ALPHA_R_GPDISP:
 647       /* The LITUSE and GPDISP relocs do not use a symbol, or an
 648          addend, but they do use a special code.  Put this code in the
 649          addend field.  */
 650       rptr->addend = intern->r_size;
 651       break;
 652
 653     case ALPHA_R_OP_STORE:
 654       /* The STORE reloc needs the size and offset fields.  We store
 655          them in the addend.  */
 656       BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
 657       rptr->addend = (intern->r_offset << 8) + intern->r_size;
 658       break;
 659
 660     case ALPHA_R_OP_PUSH:
 661     case ALPHA_R_OP_PSUB:
 662     case ALPHA_R_OP_PRSHIFT:
 663       /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
 664          address.  I believe that the address supplied is really an
 665          addend.  */
 666       rptr->addend = intern->r_vaddr;
 667       break;
 668
 669     case ALPHA_R_GPVALUE:
 670       /* Set the addend field to the new GP value.  */
 671       rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
 672       break;
 673
 674     case ALPHA_R_IGNORE:
 675       /* If the type is ALPHA_R_IGNORE, make sure this is a reference
 676          to the absolute section so that the reloc is ignored.  For
 677          some reason the address of this reloc type is not adjusted by
 678          the section vma.  We record the gp value for this object file
 679          here, for convenience when doing the GPDISP relocation.  */
 680       rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 681       rptr->address = intern->r_vaddr;
 682       rptr->addend = ecoff_data (abfd)->gp;
 683       break;
 684
 685     default:
 686       break;
 687     }
 688
 689   rptr->howto = &alpha_howto_table[intern->r_type];
 690 }
 691
 692 /* When writing out a reloc we need to pull some values back out of
 693    the addend field into the reloc.  This is roughly the reverse of
 694    alpha_adjust_reloc_in, except that there are several changes we do
 695    not need to undo.  */
 696
 697 static void
 698 alpha_adjust_reloc_out (abfd, rel, intern)
 699      bfd *abfd;
 700      const arelent *rel;
 701      struct internal_reloc *intern;
 702 {
 703   switch (intern->r_type)
 704     {
 705     case ALPHA_R_LITUSE:
 706     case ALPHA_R_GPDISP:
 707       intern->r_size = rel->addend;
 708       break;
 709
 710     case ALPHA_R_OP_STORE:
 711       intern->r_size = rel->addend & 0xff;
 712       intern->r_offset = (rel->addend >> 8) & 0xff;
 713       break;
 714
 715     case ALPHA_R_OP_PUSH:
 716     case ALPHA_R_OP_PSUB:
 717     case ALPHA_R_OP_PRSHIFT:
 718       intern->r_vaddr = rel->addend;
 719       break;
 720
 721     case ALPHA_R_IGNORE:
 722       intern->r_vaddr = rel->address;
 723       break;
 724
 725     default:
 726       break;
 727     }
 728 }
 729
 730 /* The size of the stack for the relocation evaluator.  */
 731 #define RELOC_STACKSIZE (10)
 732
 733 /* Alpha ECOFF relocs have a built in expression evaluator as well as
 734    other interdependencies.  Rather than use a bunch of special
 735    functions and global variables, we use a single routine to do all
 736    the relocation for a section.  I haven't yet worked out how the
 737    assembler is going to handle this.  */
 738
 739 static bfd_byte *
 740 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
 741                                             data, relocateable, symbols)
 742      bfd *abfd;
 743      struct bfd_link_info *link_info;
 744      struct bfd_link_order *link_order;
 745      bfd_byte *data;
 746      boolean relocateable;
 747      asymbol **symbols;
 748 {
 749   bfd *input_bfd = link_order->u.indirect.section->owner;
 750   asection *input_section = link_order->u.indirect.section;
 751   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
 752   arelent **reloc_vector = NULL;
 753   long reloc_count;
 754   bfd *output_bfd = relocateable ? abfd : (bfd *) NULL;
 755   bfd_vma gp;
 756   boolean gp_undefined;
 757   bfd_vma stack[RELOC_STACKSIZE];
 758   int tos = 0;
 759
 760   if (reloc_size < 0)
 761     goto error_return;
 762   reloc_vector = (arelent **) malloc (reloc_size);
 763   if (reloc_vector == NULL && reloc_size != 0)
 764     {
 765       bfd_set_error (bfd_error_no_memory);
 766       goto error_return;
 767     }
 768
 769   if (! bfd_get_section_contents (input_bfd, input_section, data,
 770                                   (file_ptr) 0, input_section->_raw_size))
 771     goto error_return;
 772
 773   /* The section size is not going to change.  */
 774   input_section->_cooked_size = input_section->_raw_size;
 775   input_section->reloc_done = true;
 776
 777   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
 778                                         reloc_vector, symbols);
 779   if (reloc_count < 0)
 780     goto error_return;
 781   if (reloc_count == 0)
 782     goto successful_return;
 783
 784   /* Get the GP value for the output BFD.  */
 785   gp_undefined = false;
 786   if (ecoff_data (abfd)->gp == 0)
 787     {
 788       if (relocateable != false)
 789         {
 790           asection *sec;
 791           bfd_vma lo;
 792
 793           /* Make up a value.  */
 794           lo = (bfd_vma) -1;
 795           for (sec = abfd->sections; sec != NULL; sec = sec->next)
 796             {
 797               if (sec->vma < lo
 798                   && (strcmp (sec->name, ".sbss") == 0
 799                       || strcmp (sec->name, ".sdata") == 0
 800                       || strcmp (sec->name, ".lit4") == 0
 801                       || strcmp (sec->name, ".lit8") == 0
 802                       || strcmp (sec->name, ".lita") == 0))
 803                 lo = sec->vma;
 804             }
 805           ecoff_data (abfd)->gp = lo + 0x8000;
 806         }
 807       else
 808         {
 809           struct bfd_link_hash_entry *h;
 810
 811           h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false,
 812                                     true);
 813           if (h == (struct bfd_link_hash_entry *) NULL
 814               || h->type != bfd_link_hash_defined)
 815             gp_undefined = true;
 816           else
 817             ecoff_data (abfd)->gp = (h->u.def.value
 818                                      + h->u.def.section->output_section->vma
 819                                      + h->u.def.section->output_offset);
 820         }
 821     }
 822   gp = ecoff_data (abfd)->gp;
 823
 824   for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
 825     {
 826       arelent *rel;
 827       bfd_reloc_status_type r;
 828       char *err;
 829
 830       rel = *reloc_vector;
 831       r = bfd_reloc_ok;
 832       switch (rel->howto->type)
 833         {
 834         case ALPHA_R_IGNORE:
 835           rel->address += input_section->output_offset;
 836           break;
 837
 838         case ALPHA_R_REFLONG:
 839         case ALPHA_R_REFQUAD:
 840         case ALPHA_R_BRADDR:
 841         case ALPHA_R_HINT:
 842         case ALPHA_R_SREL16:
 843         case ALPHA_R_SREL32:
 844         case ALPHA_R_SREL64:
 845           if (relocateable
 846               && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
 847             {
 848               rel->address += input_section->output_offset;
 849               break;
 850             }
 851           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 852                                       output_bfd, &err);
 853           break;
 854
 855         case ALPHA_R_GPREL32:
 856           /* This relocation is used in a switch table.  It is a 32
 857              bit offset from the current GP value.  We must adjust it
 858              by the different between the original GP value and the
 859              current GP value.  The original GP value is stored in the
 860              addend.  We adjust the addend and let
 861              bfd_perform_relocation finish the job.  */
 862           rel->addend -= gp;
 863           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 864                                       output_bfd, &err);
 865           if (r == bfd_reloc_ok && gp_undefined)
 866             {
 867               r = bfd_reloc_dangerous;
 868               err = (char *) "GP relative relocation used when GP not defined";
 869             }
 870           break;
 871
 872         case ALPHA_R_LITERAL:
 873           /* This is a reference to a literal value, generally
 874              (always?) in the .lita section.  This is a 16 bit GP
 875              relative relocation.  Sometimes the subsequent reloc is a
 876              LITUSE reloc, which indicates how this reloc is used.
 877              This sometimes permits rewriting the two instructions
 878              referred to by the LITERAL and the LITUSE into different
 879              instructions which do not refer to .lita.  This can save
 880              a memory reference, and permits removing a value from
 881              .lita thus saving GP relative space.
 882
 883              We do not these optimizations.  To do them we would need
 884              to arrange to link the .lita section first, so that by
 885              the time we got here we would know the final values to
 886              use.  This would not be particularly difficult, but it is
 887              not currently implemented.  */
 888
 889           {
 890             unsigned long insn;
 891
 892             /* I believe that the LITERAL reloc will only apply to a
 893                ldq or ldl instruction, so check my assumption.  */
 894             insn = bfd_get_32 (input_bfd, data + rel->address);
 895             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
 896                         || ((insn >> 26) & 0x3f) == 0x28);
 897
 898             rel->addend -= gp;
 899             r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 900                                         output_bfd, &err);
 901             if (r == bfd_reloc_ok && gp_undefined)
 902               {
 903                 r = bfd_reloc_dangerous;
 904                 err =
 905                   (char *) "GP relative relocation used when GP not defined";
 906               }
 907           }
 908           break;
 909
 910         case ALPHA_R_LITUSE:
 911           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
 912              does not cause anything to happen, itself.  */
 913           rel->address += input_section->output_offset;
 914           break;
 915
 916         case ALPHA_R_GPDISP:
 917           /* This marks the ldah of an ldah/lda pair which loads the
 918              gp register with the difference of the gp value and the
 919              current location.  The second of the pair is r_size bytes
 920              ahead, and is marked with an ALPHA_R_IGNORE reloc.  */
 921           {
 922             unsigned long insn1, insn2;
 923             bfd_vma addend;
 924
 925             BFD_ASSERT (reloc_vector[1] != NULL
 926                         && reloc_vector[1]->howto->type == ALPHA_R_IGNORE
 927                         && (rel->address + rel->addend
 928                             == reloc_vector[1]->address));
 929
 930             /* Get the two instructions.  */
 931             insn1 = bfd_get_32 (input_bfd, data + rel->address);
 932             insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
 933
 934             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
 935             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
 936
 937             /* Get the existing addend.  We must account for the sign
 938                extension done by lda and ldah.  */
 939             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
 940             if (insn1 & 0x8000)
 941               {
 942                 addend -= 0x80000000;
 943                 addend -= 0x80000000;
 944               }
 945             if (insn2 & 0x8000)
 946               addend -= 0x10000;
 947
 948             /* The existing addend includes the different between the
 949                gp of the input BFD and the address in the input BFD.
 950                Subtract this out.  */
 951             addend -= (reloc_vector[1]->addend
 952                        - (input_section->vma + rel->address));
 953
 954             /* Now add in the final gp value, and subtract out the
 955                final address.  */
 956             addend += (gp
 957                        - (input_section->output_section->vma
 958                           + input_section->output_offset
 959                           + rel->address));
 960
 961             /* Change the instructions, accounting for the sign
 962                extension, and write them out.  */
 963             if (addend & 0x8000)
 964               addend += 0x10000;
 965             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
 966             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
 967
 968             bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
 969             bfd_put_32 (input_bfd, (bfd_vma) insn2,
 970                         data + rel->address + rel->addend);
 971
 972             rel->address += input_section->output_offset;
 973           }
 974           break;
 975
 976         case ALPHA_R_OP_PUSH:
 977           /* Push a value on the reloc evaluation stack.  */
 978           {
 979             asymbol *symbol;
 980             bfd_vma relocation;
 981
 982             if (relocateable)
 983               {
 984                 rel->address += input_section->output_offset;
 985                 break;
 986               }
 987
 988             /* Figure out the relocation of this symbol.  */
 989             symbol = *rel->sym_ptr_ptr;
 990
 991             if (bfd_is_und_section (symbol->section))
 992               r = bfd_reloc_undefined;
 993
 994             if (bfd_is_com_section (symbol->section))
 995               relocation = 0;
 996             else
 997               relocation = symbol->value;
 998             relocation += symbol->section->output_section->vma;
 999             relocation += symbol->section->output_offset;
1000             relocation += rel->addend;
1001
1002             if (tos >= RELOC_STACKSIZE)
1003               abort ();
1004
1005             stack[tos++] = relocation;
1006           }
1007           break;
1008
1009         case ALPHA_R_OP_STORE:
1010           /* Store a value from the reloc stack into a bitfield.  */
1011           {
1012             bfd_vma val;
1013             int offset, size;
1014
1015             if (relocateable)
1016               {
1017                 rel->address += input_section->output_offset;
1018                 break;
1019               }
1020
1021             if (tos == 0)
1022               abort ();
1023
1024             /* The offset and size for this reloc are encoded into the
1025                addend field by alpha_adjust_reloc_in.  */
1026             offset = (rel->addend >> 8) & 0xff;
1027             size = rel->addend & 0xff;
1028
1029             val = bfd_get_64 (abfd, data + rel->address);
1030             val &=~ (((1 << size) - 1) << offset);
1031             val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1032             bfd_put_64 (abfd, val, data + rel->address);
1033           }
1034           break;
1035
1036         case ALPHA_R_OP_PSUB:
1037           /* Subtract a value from the top of the stack.  */
1038           {
1039             asymbol *symbol;
1040             bfd_vma relocation;
1041
1042             if (relocateable)
1043               {
1044                 rel->address += input_section->output_offset;
1045                 break;
1046               }
1047
1048             /* Figure out the relocation of this symbol.  */
1049             symbol = *rel->sym_ptr_ptr;
1050
1051             if (bfd_is_und_section (symbol->section))
1052               r = bfd_reloc_undefined;
1053
1054             if (bfd_is_com_section (symbol->section))
1055               relocation = 0;
1056             else
1057               relocation = symbol->value;
1058             relocation += symbol->section->output_section->vma;
1059             relocation += symbol->section->output_offset;
1060             relocation += rel->addend;
1061
1062             if (tos == 0)
1063               abort ();
1064
1065             stack[tos - 1] -= relocation;
1066           }
1067           break;
1068
1069         case ALPHA_R_OP_PRSHIFT:
1070           /* Shift the value on the top of the stack.  */
1071           {
1072             asymbol *symbol;
1073             bfd_vma relocation;
1074
1075             if (relocateable)
1076               {
1077                 rel->address += input_section->output_offset;
1078                 break;
1079               }
1080
1081             /* Figure out the relocation of this symbol.  */
1082             symbol = *rel->sym_ptr_ptr;
1083
1084             if (bfd_is_und_section (symbol->section))
1085               r = bfd_reloc_undefined;
1086
1087             if (bfd_is_com_section (symbol->section))
1088               relocation = 0;
1089             else
1090               relocation = symbol->value;
1091             relocation += symbol->section->output_section->vma;
1092             relocation += symbol->section->output_offset;
1093             relocation += rel->addend;
1094
1095             if (tos == 0)
1096               abort ();
1097
1098             stack[tos - 1] >>= relocation;
1099           }
1100           break;
1101
1102         case ALPHA_R_GPVALUE:
1103           /* I really don't know if this does the right thing.  */
1104           gp = rel->addend;
1105           gp_undefined = false;
1106           break;
1107
1108         default:
1109           abort ();
1110         }
1111
1112       if (relocateable)
1113         {
1114           asection *os = input_section->output_section;
1115
1116           /* A partial link, so keep the relocs.  */
1117           os->orelocation[os->reloc_count] = rel;
1118           os->reloc_count++;
1119         }
1120
1121       if (r != bfd_reloc_ok)
1122         {
1123           switch (r)
1124             {
1125             case bfd_reloc_undefined:
1126               if (! ((*link_info->callbacks->undefined_symbol)
1127                      (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1128                       input_bfd, input_section, rel->address)))
1129                 goto error_return;
1130               break;
1131             case bfd_reloc_dangerous:
1132               if (! ((*link_info->callbacks->reloc_dangerous)
1133                      (link_info, err, input_bfd, input_section,
1134                       rel->address)))
1135                 goto error_return;
1136               break;
1137             case bfd_reloc_overflow:
1138               if (! ((*link_info->callbacks->reloc_overflow)
1139                      (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1140                       rel->howto->name, rel->addend, input_bfd,
1141                       input_section, rel->address)))
1142                 goto error_return;
1143               break;
1144             case bfd_reloc_outofrange:
1145             default:
1146               abort ();
1147               break;
1148             }
1149         }
1150     }
1151
1152   if (tos != 0)
1153     abort ();
1154
1155  successful_return:
1156   if (reloc_vector != NULL)
1157     free (reloc_vector);
1158   return data;
1159
1160  error_return:
1161   if (reloc_vector != NULL)
1162     free (reloc_vector);
1163   return NULL;
1164 }
1165
1166 /* Get the howto structure for a generic reloc type.  */
1167
1168 static reloc_howto_type *
1169 alpha_bfd_reloc_type_lookup (abfd, code)
1170      bfd *abfd;
1171      bfd_reloc_code_real_type code;
1172 {
1173   int alpha_type;
1174
1175   switch (code)
1176     {
1177     case BFD_RELOC_32:
1178       alpha_type = ALPHA_R_REFLONG;
1179       break;
1180     case BFD_RELOC_64:
1181     case BFD_RELOC_CTOR:
1182       alpha_type = ALPHA_R_REFQUAD;
1183       break;
1184     case BFD_RELOC_GPREL32:
1185       alpha_type = ALPHA_R_GPREL32;
1186       break;
1187     case BFD_RELOC_ALPHA_LITERAL:
1188       alpha_type = ALPHA_R_LITERAL;
1189       break;
1190     case BFD_RELOC_ALPHA_LITUSE:
1191       alpha_type = ALPHA_R_LITUSE;
1192       break;
1193     case BFD_RELOC_ALPHA_GPDISP_HI16:
1194       alpha_type = ALPHA_R_GPDISP;
1195       break;
1196     case BFD_RELOC_ALPHA_GPDISP_LO16:
1197       alpha_type = ALPHA_R_IGNORE;
1198       break;
1199     case BFD_RELOC_23_PCREL_S2:
1200       alpha_type = ALPHA_R_BRADDR;
1201       break;
1202     case BFD_RELOC_ALPHA_HINT:
1203       alpha_type = ALPHA_R_HINT;
1204       break;
1205     case BFD_RELOC_16_PCREL:
1206       alpha_type = ALPHA_R_SREL16;
1207       break;
1208     case BFD_RELOC_32_PCREL:
1209       alpha_type = ALPHA_R_SREL32;
1210       break;
1211     case BFD_RELOC_64_PCREL:
1212       alpha_type = ALPHA_R_SREL64;
1213       break;
1214 #if 0
1215     case ???:
1216       alpha_type = ALPHA_R_OP_PUSH;
1217       break;
1218     case ???:
1219       alpha_type = ALPHA_R_OP_STORE;
1220       break;
1221     case ???:
1222       alpha_type = ALPHA_R_OP_PSUB;
1223       break;
1224     case ???:
1225       alpha_type = ALPHA_R_OP_PRSHIFT;
1226       break;
1227     case ???:
1228       alpha_type = ALPHA_R_GPVALUE;
1229       break;
1230 #endif
1231     default:
1232       return (reloc_howto_type *) NULL;
1233     }
1234
1235   return &alpha_howto_table[alpha_type];
1236 }
1237 \f
1238 /* A helper routine for alpha_relocate_section which converts an
1239    external reloc when generating relocateable output.  Returns the
1240    relocation amount.  */
1241
1242 static bfd_vma
1243 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1244      bfd *output_bfd;
1245      struct bfd_link_info *info;
1246      bfd *input_bfd;
1247      struct external_reloc *ext_rel;
1248      struct ecoff_link_hash_entry *h;
1249 {
1250   unsigned long r_symndx;
1251   bfd_vma relocation;
1252
1253   BFD_ASSERT (info->relocateable);
1254
1255   if (h->root.type == bfd_link_hash_defined
1256       || h->root.type == bfd_link_hash_defweak)
1257     {
1258       asection *hsec;
1259       const char *name;
1260
1261       /* This symbol is defined in the output.  Convert the reloc from
1262          being against the symbol to being against the section.  */
1263
1264       /* Clear the r_extern bit.  */
1265       ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1266
1267       /* Compute a new r_symndx value.  */
1268       hsec = h->root.u.def.section;
1269       name = bfd_get_section_name (output_bfd, hsec->output_section);
1270
1271       r_symndx = -1;
1272       switch (name[1])
1273         {
1274         case 'A':
1275           if (strcmp (name, "*ABS*") == 0)
1276             r_symndx = RELOC_SECTION_ABS;
1277           break;
1278         case 'b':
1279           if (strcmp (name, ".bss") == 0)
1280             r_symndx = RELOC_SECTION_BSS;
1281           break;
1282         case 'd':
1283           if (strcmp (name, ".data") == 0)
1284             r_symndx = RELOC_SECTION_DATA;
1285           break;
1286         case 'f':
1287           if (strcmp (name, ".fini") == 0)
1288             r_symndx = RELOC_SECTION_FINI;
1289           break;
1290         case 'i':
1291           if (strcmp (name, ".init") == 0)
1292             r_symndx = RELOC_SECTION_INIT;
1293           break;
1294         case 'l':
1295           if (strcmp (name, ".lita") == 0)
1296             r_symndx = RELOC_SECTION_LITA;
1297           else if (strcmp (name, ".lit8") == 0)
1298             r_symndx = RELOC_SECTION_LIT8;
1299           else if (strcmp (name, ".lit4") == 0)
1300             r_symndx = RELOC_SECTION_LIT4;
1301           break;
1302         case 'p':
1303           if (strcmp (name, ".pdata") == 0)
1304             r_symndx = RELOC_SECTION_PDATA;
1305           break;
1306         case 'r':
1307           if (strcmp (name, ".rdata") == 0)
1308             r_symndx = RELOC_SECTION_RDATA;
1309           else if (strcmp (name, ".rconst") == 0)
1310             r_symndx = RELOC_SECTION_RCONST;
1311           break;
1312         case 's':
1313           if (strcmp (name, ".sdata") == 0)
1314             r_symndx = RELOC_SECTION_SDATA;
1315           else if (strcmp (name, ".sbss") == 0)
1316             r_symndx = RELOC_SECTION_SBSS;
1317           break;
1318         case 't':
1319           if (strcmp (name, ".text") == 0)
1320             r_symndx = RELOC_SECTION_TEXT;
1321           break;
1322         case 'x':
1323           if (strcmp (name, ".xdata") == 0)
1324             r_symndx = RELOC_SECTION_XDATA;
1325           break;
1326         }
1327
1328       if (r_symndx == -1)
1329         abort ();
1330
1331       /* Add the section VMA and the symbol value.  */
1332       relocation = (h->root.u.def.value
1333                     + hsec->output_section->vma
1334                     + hsec->output_offset);
1335     }
1336   else
1337     {
1338       /* Change the symndx value to the right one for
1339          the output BFD.  */
1340       r_symndx = h->indx;
1341       if (r_symndx == -1)
1342         {
1343           /* Caller must give an error.  */
1344           r_symndx = 0;
1345         }
1346       relocation = 0;
1347     }
1348
1349   /* Write out the new r_symndx value.  */
1350   bfd_h_put_32 (input_bfd, (bfd_vma) r_symndx,
1351                 (bfd_byte *) ext_rel->r_symndx);
1352
1353   return relocation;
1354 }
1355
1356 /* Relocate a section while linking an Alpha ECOFF file.  This is
1357    quite similar to get_relocated_section_contents.  Perhaps they
1358    could be combined somehow.  */
1359
1360 static boolean
1361 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1362                         contents, external_relocs)
1363      bfd *output_bfd;
1364      struct bfd_link_info *info;
1365      bfd *input_bfd;
1366      asection *input_section;
1367      bfd_byte *contents;
1368      PTR external_relocs;
1369 {
1370   asection **symndx_to_section;
1371   struct ecoff_link_hash_entry **sym_hashes;
1372   bfd_vma gp;
1373   boolean gp_undefined;
1374   bfd_vma stack[RELOC_STACKSIZE];
1375   int tos = 0;
1376   struct external_reloc *ext_rel;
1377   struct external_reloc *ext_rel_end;
1378
1379   /* We keep a table mapping the symndx found in an internal reloc to
1380      the appropriate section.  This is faster than looking up the
1381      section by name each time.  */
1382   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1383   if (symndx_to_section == (asection **) NULL)
1384     {
1385       symndx_to_section = ((asection **)
1386                            bfd_alloc (input_bfd,
1387                                       (NUM_RELOC_SECTIONS
1388                                        * sizeof (asection *))));
1389       if (!symndx_to_section)
1390         return false;
1391
1392       symndx_to_section[RELOC_SECTION_NONE] = NULL;
1393       symndx_to_section[RELOC_SECTION_TEXT] =
1394         bfd_get_section_by_name (input_bfd, ".text");
1395       symndx_to_section[RELOC_SECTION_RDATA] =
1396         bfd_get_section_by_name (input_bfd, ".rdata");
1397       symndx_to_section[RELOC_SECTION_DATA] =
1398         bfd_get_section_by_name (input_bfd, ".data");
1399       symndx_to_section[RELOC_SECTION_SDATA] =
1400         bfd_get_section_by_name (input_bfd, ".sdata");
1401       symndx_to_section[RELOC_SECTION_SBSS] =
1402         bfd_get_section_by_name (input_bfd, ".sbss");
1403       symndx_to_section[RELOC_SECTION_BSS] =
1404         bfd_get_section_by_name (input_bfd, ".bss");
1405       symndx_to_section[RELOC_SECTION_INIT] =
1406         bfd_get_section_by_name (input_bfd, ".init");
1407       symndx_to_section[RELOC_SECTION_LIT8] =
1408         bfd_get_section_by_name (input_bfd, ".lit8");
1409       symndx_to_section[RELOC_SECTION_LIT4] =
1410         bfd_get_section_by_name (input_bfd, ".lit4");
1411       symndx_to_section[RELOC_SECTION_XDATA] =
1412         bfd_get_section_by_name (input_bfd, ".xdata");
1413       symndx_to_section[RELOC_SECTION_PDATA] =
1414         bfd_get_section_by_name (input_bfd, ".pdata");
1415       symndx_to_section[RELOC_SECTION_FINI] =
1416         bfd_get_section_by_name (input_bfd, ".fini");
1417       symndx_to_section[RELOC_SECTION_LITA] =
1418         bfd_get_section_by_name (input_bfd, ".lita");
1419       symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1420       symndx_to_section[RELOC_SECTION_RCONST] =
1421         bfd_get_section_by_name (input_bfd, ".rconst");
1422
1423       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1424     }
1425
1426   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1427
1428   gp = ecoff_data (output_bfd)->gp;
1429   if (gp == 0)
1430     gp_undefined = true;
1431   else
1432     gp_undefined = false;
1433
1434   BFD_ASSERT (output_bfd->xvec->header_byteorder_big_p == false);
1435   BFD_ASSERT (input_bfd->xvec->header_byteorder_big_p == false);
1436
1437   ext_rel = (struct external_reloc *) external_relocs;
1438   ext_rel_end = ext_rel + input_section->reloc_count;
1439   for (; ext_rel < ext_rel_end; ext_rel++)
1440     {
1441       bfd_vma r_vaddr;
1442       unsigned long r_symndx;
1443       int r_type;
1444       int r_extern;
1445       int r_offset;
1446       int r_size;
1447       boolean relocatep;
1448       boolean adjust_addrp;
1449       boolean gp_usedp;
1450       bfd_vma addend;
1451
1452       r_vaddr = bfd_h_get_64 (input_bfd, (bfd_byte *) ext_rel->r_vaddr);
1453       r_symndx = bfd_h_get_32 (input_bfd, (bfd_byte *) ext_rel->r_symndx);
1454
1455       r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1456                 >> RELOC_BITS0_TYPE_SH_LITTLE);
1457       r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1458       r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1459                   >> RELOC_BITS1_OFFSET_SH_LITTLE);
1460       /* Ignored the reserved bits.  */
1461       r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1462                 >> RELOC_BITS3_SIZE_SH_LITTLE);
1463
1464       relocatep = false;
1465       adjust_addrp = true;
1466       gp_usedp = false;
1467       addend = 0;
1468
1469       switch (r_type)
1470         {
1471         default:
1472           abort ();
1473
1474         case ALPHA_R_IGNORE:
1475           /* This reloc appears after a GPDISP reloc.  It marks the
1476              position of the second instruction to be altered by the
1477              GPDISP reloc, but is not otherwise used for anything.
1478              For some reason, the address of the relocation does not
1479              appear to include the section VMA, unlike the other
1480              relocation types.  */
1481           if (info->relocateable)
1482             bfd_h_put_64 (input_bfd,
1483                           input_section->output_offset + r_vaddr,
1484                           (bfd_byte *) ext_rel->r_vaddr);
1485           adjust_addrp = false;
1486           break;
1487
1488         case ALPHA_R_REFLONG:
1489         case ALPHA_R_REFQUAD:
1490         case ALPHA_R_BRADDR:
1491         case ALPHA_R_HINT:
1492         case ALPHA_R_SREL16:
1493         case ALPHA_R_SREL32:
1494         case ALPHA_R_SREL64:
1495           relocatep = true;
1496           break;
1497
1498         case ALPHA_R_GPREL32:
1499           /* This relocation is used in a switch table.  It is a 32
1500              bit offset from the current GP value.  We must adjust it
1501              by the different between the original GP value and the
1502              current GP value.  */
1503           relocatep = true;
1504           addend = ecoff_data (input_bfd)->gp - gp;
1505           gp_usedp = true;
1506           break;
1507
1508         case ALPHA_R_LITERAL:
1509           /* This is a reference to a literal value, generally
1510              (always?) in the .lita section.  This is a 16 bit GP
1511              relative relocation.  Sometimes the subsequent reloc is a
1512              LITUSE reloc, which indicates how this reloc is used.
1513              This sometimes permits rewriting the two instructions
1514              referred to by the LITERAL and the LITUSE into different
1515              instructions which do not refer to .lita.  This can save
1516              a memory reference, and permits removing a value from
1517              .lita thus saving GP relative space.
1518
1519              We do not these optimizations.  To do them we would need
1520              to arrange to link the .lita section first, so that by
1521              the time we got here we would know the final values to
1522              use.  This would not be particularly difficult, but it is
1523              not currently implemented.  */
1524
1525           /* I believe that the LITERAL reloc will only apply to a ldq
1526              or ldl instruction, so check my assumption.  */
1527           {
1528             unsigned long insn;
1529
1530             insn = bfd_get_32 (input_bfd,
1531                                contents + r_vaddr - input_section->vma);
1532             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1533                         || ((insn >> 26) & 0x3f) == 0x28);
1534           }
1535
1536           relocatep = true;
1537           addend = ecoff_data (input_bfd)->gp - gp;
1538           gp_usedp = true;
1539           break;
1540
1541         case ALPHA_R_LITUSE:
1542           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
1543              does not cause anything to happen, itself.  */
1544           break;
1545
1546         case ALPHA_R_GPDISP:
1547           /* This marks the ldah of an ldah/lda pair which loads the
1548              gp register with the difference of the gp value and the
1549              current location.  The second of the pair is r_symndx
1550              bytes ahead, and is also marked with an ALPHA_R_IGNORE
1551              reloc.  */
1552           {
1553             unsigned long insn1, insn2;
1554
1555             BFD_ASSERT (ext_rel + 1 < ext_rel_end
1556                         && (((ext_rel + 1)->r_bits[0]
1557                              & RELOC_BITS0_TYPE_LITTLE)
1558                             >> RELOC_BITS0_TYPE_SH_LITTLE) == ALPHA_R_IGNORE
1559                         && (bfd_h_get_64 (input_bfd,
1560                                           (bfd_byte *) (ext_rel + 1)->r_vaddr)
1561                             == r_vaddr - input_section->vma + r_symndx));
1562
1563             /* Get the two instructions.  */
1564             insn1 = bfd_get_32 (input_bfd,
1565                                 contents + r_vaddr - input_section->vma);
1566             insn2 = bfd_get_32 (input_bfd,
1567                                 (contents
1568                                  + r_vaddr
1569                                  - input_section->vma
1570                                  + r_symndx));
1571
1572             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1573             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1574
1575             /* Get the existing addend.  We must account for the sign
1576                extension done by lda and ldah.  */
1577             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1578             if (insn1 & 0x8000)
1579               {
1580                 /* This is addend -= 0x100000000 without causing an
1581                    integer overflow on a 32 bit host.  */
1582                 addend -= 0x80000000;
1583                 addend -= 0x80000000;
1584               }
1585             if (insn2 & 0x8000)
1586               addend -= 0x10000;
1587
1588             /* The existing addend includes the difference between the
1589                gp of the input BFD and the address in the input BFD.
1590                We want to change this to the difference between the
1591                final GP and the final address.  */
1592             addend += (gp
1593                        - ecoff_data (input_bfd)->gp
1594                        + input_section->vma
1595                        - (input_section->output_section->vma
1596                           + input_section->output_offset));
1597
1598             /* Change the instructions, accounting for the sign
1599                extension, and write them out.  */
1600             if (addend & 0x8000)
1601               addend += 0x10000;
1602             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1603             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1604
1605             bfd_put_32 (input_bfd, (bfd_vma) insn1,
1606                         contents + r_vaddr - input_section->vma);
1607             bfd_put_32 (input_bfd, (bfd_vma) insn2,
1608                         contents + r_vaddr - input_section->vma + r_symndx);
1609
1610             gp_usedp = true;
1611           }
1612           break;
1613
1614         case ALPHA_R_OP_PUSH:
1615         case ALPHA_R_OP_PSUB:
1616         case ALPHA_R_OP_PRSHIFT:
1617           /* Manipulate values on the reloc evaluation stack.  The
1618              r_vaddr field is not an address in input_section, it is
1619              the current value (including any addend) of the object
1620              being used.  */
1621           if (! r_extern)
1622             {
1623               asection *s;
1624
1625               s = symndx_to_section[r_symndx];
1626               if (s == (asection *) NULL)
1627                 abort ();
1628               addend = s->output_section->vma + s->output_offset - s->vma;
1629             }
1630           else
1631             {
1632               struct ecoff_link_hash_entry *h;
1633
1634               h = sym_hashes[r_symndx];
1635               if (h == (struct ecoff_link_hash_entry *) NULL)
1636                 abort ();
1637
1638               if (! info->relocateable)
1639                 {
1640                   if (h->root.type == bfd_link_hash_defined
1641                       || h->root.type == bfd_link_hash_defweak)
1642                     addend = (h->root.u.def.value
1643                               + h->root.u.def.section->output_section->vma
1644                               + h->root.u.def.section->output_offset);
1645                   else
1646                     {
1647                       /* Note that we pass the address as 0, since we
1648                          do not have a meaningful number for the
1649                          location within the section that is being
1650                          relocated.  */
1651                       if (! ((*info->callbacks->undefined_symbol)
1652                              (info, h->root.root.string, input_bfd,
1653                               input_section, (bfd_vma) 0)))
1654                         return false;
1655                       addend = 0;
1656                     }
1657                 }
1658               else
1659                 {
1660                   if (h->root.type != bfd_link_hash_defined
1661                       && h->root.type != bfd_link_hash_defweak
1662                       && h->indx == -1)
1663                     {
1664                       /* This symbol is not being written out.  Pass
1665                          the address as 0, as with undefined_symbol,
1666                          above.  */
1667                       if (! ((*info->callbacks->unattached_reloc)
1668                              (info, h->root.root.string, input_bfd,
1669                               input_section, (bfd_vma) 0)))
1670                         return false;
1671                     }
1672
1673                   addend = alpha_convert_external_reloc (output_bfd, info,
1674                                                          input_bfd,
1675                                                          ext_rel, h);
1676                 }
1677             }
1678
1679           addend += r_vaddr;
1680
1681           if (info->relocateable)
1682             {
1683               /* Adjust r_vaddr by the addend.  */
1684               bfd_h_put_64 (input_bfd, addend,
1685                             (bfd_byte *) ext_rel->r_vaddr);
1686             }
1687           else
1688             {
1689               switch (r_type)
1690                 {
1691                 case ALPHA_R_OP_PUSH:
1692                   if (tos >= RELOC_STACKSIZE)
1693                     abort ();
1694                   stack[tos++] = addend;
1695                   break;
1696
1697                 case ALPHA_R_OP_PSUB:
1698                   if (tos == 0)
1699                     abort ();
1700                   stack[tos - 1] -= addend;
1701                   break;
1702
1703                 case ALPHA_R_OP_PRSHIFT:
1704                   if (tos == 0)
1705                     abort ();
1706                   stack[tos - 1] >>= addend;
1707                   break;
1708                 }
1709             }
1710
1711           adjust_addrp = false;
1712           break;
1713
1714         case ALPHA_R_OP_STORE:
1715           /* Store a value from the reloc stack into a bitfield.  If
1716              we are generating relocateable output, all we do is
1717              adjust the address of the reloc.  */
1718           if (! info->relocateable)
1719             {
1720               bfd_vma mask;
1721               bfd_vma val;
1722
1723               if (tos == 0)
1724                 abort ();
1725
1726               /* Get the relocation mask.  The separate steps and the
1727                  casts to bfd_vma are attempts to avoid a bug in the
1728                  Alpha OSF 1.3 C compiler.  See reloc.c for more
1729                  details.  */
1730               mask = 1;
1731               mask <<= (bfd_vma) r_size;
1732               mask -= 1;
1733
1734               /* FIXME: I don't know what kind of overflow checking,
1735                  if any, should be done here.  */
1736               val = bfd_get_64 (input_bfd,
1737                                 contents + r_vaddr - input_section->vma);
1738               val &=~ mask << (bfd_vma) r_offset;
1739               val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1740               bfd_put_64 (input_bfd, val,
1741                           contents + r_vaddr - input_section->vma);
1742             }
1743           break;
1744
1745         case ALPHA_R_GPVALUE:
1746           /* I really don't know if this does the right thing.  */
1747           gp = ecoff_data (input_bfd)->gp + r_symndx;
1748           gp_undefined = false;
1749           break;
1750         }
1751
1752       if (relocatep)
1753         {
1754           reloc_howto_type *howto;
1755           struct ecoff_link_hash_entry *h = NULL;
1756           asection *s = NULL;
1757           bfd_vma relocation;
1758           bfd_reloc_status_type r;
1759
1760           /* Perform a relocation.  */
1761
1762           howto = &alpha_howto_table[r_type];
1763
1764           if (r_extern)
1765             {
1766               h = sym_hashes[r_symndx];
1767               /* If h is NULL, that means that there is a reloc
1768                  against an external symbol which we thought was just
1769                  a debugging symbol.  This should not happen.  */
1770               if (h == (struct ecoff_link_hash_entry *) NULL)
1771                 abort ();
1772             }
1773           else
1774             {
1775               if (r_symndx >= NUM_RELOC_SECTIONS)
1776                 s = NULL;
1777               else
1778                 s = symndx_to_section[r_symndx];
1779
1780               if (s == (asection *) NULL)
1781                 abort ();
1782             }
1783
1784           if (info->relocateable)
1785             {
1786               /* We are generating relocateable output, and must
1787                  convert the existing reloc.  */
1788               if (r_extern)
1789                 {
1790                   if (h->root.type != bfd_link_hash_defined
1791                       && h->root.type != bfd_link_hash_defweak
1792                       && h->indx == -1)
1793                     {
1794                       /* This symbol is not being written out.  */
1795                       if (! ((*info->callbacks->unattached_reloc)
1796                              (info, h->root.root.string, input_bfd,
1797                               input_section, r_vaddr - input_section->vma)))
1798                         return false;
1799                     }
1800
1801                   relocation = alpha_convert_external_reloc (output_bfd,
1802                                                              info,
1803                                                              input_bfd,
1804                                                              ext_rel,
1805                                                              h);
1806                 }
1807               else
1808                 {
1809                   /* This is a relocation against a section.  Adjust
1810                      the value by the amount the section moved.  */
1811                   relocation = (s->output_section->vma
1812                                 + s->output_offset
1813                                 - s->vma);
1814                 }
1815
1816               /* If this is PC relative, the existing object file
1817                  appears to already have the reloc worked out.  We
1818                  must subtract out the old value and add in the new
1819                  one.  */
1820               if (howto->pc_relative)
1821                 relocation -= (input_section->output_section->vma
1822                                + input_section->output_offset
1823                                - input_section->vma);
1824
1825               /* Put in any addend.  */
1826               relocation += addend;
1827
1828               /* Adjust the contents.  */
1829               r = _bfd_relocate_contents (howto, input_bfd, relocation,
1830                                           (contents
1831                                            + r_vaddr
1832                                            - input_section->vma));
1833             }
1834           else
1835             {
1836               /* We are producing a final executable.  */
1837               if (r_extern)
1838                 {
1839                   /* This is a reloc against a symbol.  */
1840                   if (h->root.type == bfd_link_hash_defined
1841                       || h->root.type == bfd_link_hash_defweak)
1842                     {
1843                       asection *hsec;
1844
1845                       hsec = h->root.u.def.section;
1846                       relocation = (h->root.u.def.value
1847                                     + hsec->output_section->vma
1848                                     + hsec->output_offset);
1849                     }
1850                   else
1851                     {
1852                       if (! ((*info->callbacks->undefined_symbol)
1853                              (info, h->root.root.string, input_bfd,
1854                               input_section,
1855                               r_vaddr - input_section->vma)))
1856                         return false;
1857                       relocation = 0;
1858                     }
1859                 }
1860               else
1861                 {
1862                   /* This is a reloc against a section.  */
1863                   relocation = (s->output_section->vma
1864                                 + s->output_offset
1865                                 - s->vma);
1866
1867                   /* Adjust a PC relative relocation by removing the
1868                      reference to the original source section.  */
1869                   if (howto->pc_relative)
1870                     relocation += input_section->vma;
1871                 }
1872
1873               r = _bfd_final_link_relocate (howto,
1874                                             input_bfd,
1875                                             input_section,
1876                                             contents,
1877                                             r_vaddr - input_section->vma,
1878                                             relocation,
1879                                             addend);
1880             }
1881
1882           if (r != bfd_reloc_ok)
1883             {
1884               switch (r)
1885                 {
1886                 default:
1887                 case bfd_reloc_outofrange:
1888                   abort ();
1889                 case bfd_reloc_overflow:
1890                   {
1891                     const char *name;
1892
1893                     if (r_extern)
1894                       name = sym_hashes[r_symndx]->root.root.string;
1895                     else
1896                       name = bfd_section_name (input_bfd,
1897                                                symndx_to_section[r_symndx]);
1898                     if (! ((*info->callbacks->reloc_overflow)
1899                            (info, name, alpha_howto_table[r_type].name,
1900                             (bfd_vma) 0, input_bfd, input_section,
1901                             r_vaddr - input_section->vma)))
1902                       return false;
1903                   }
1904                   break;
1905                 }
1906             }
1907         }
1908
1909       if (info->relocateable && adjust_addrp)
1910         {
1911           /* Change the address of the relocation.  */
1912           bfd_h_put_64 (input_bfd,
1913                         (input_section->output_section->vma
1914                          + input_section->output_offset
1915                          - input_section->vma
1916                          + r_vaddr),
1917                         (bfd_byte *) ext_rel->r_vaddr);
1918         }
1919
1920       if (gp_usedp && gp_undefined)
1921         {
1922           if (! ((*info->callbacks->reloc_dangerous)
1923                  (info, "GP relative relocation when GP not defined",
1924                   input_bfd, input_section, r_vaddr - input_section->vma)))
1925             return false;
1926           /* Only give the error once per link.  */
1927           ecoff_data (output_bfd)->gp = gp = 4;
1928           gp_undefined = false;
1929         }
1930     }
1931
1932   if (tos != 0)
1933     abort ();
1934
1935   return true;
1936 }
1937 \f
1938 /* Do final adjustments to the filehdr and the aouthdr.  This routine
1939    sets the dynamic bits in the file header.  */
1940
1941 /*ARGSUSED*/
1942 static boolean
1943 alpha_adjust_headers (abfd, fhdr, ahdr)
1944      bfd *abfd;
1945      struct internal_filehdr *fhdr;
1946      struct internal_aouthdr *ahdr;
1947 {
1948   if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
1949     fhdr->f_flags |= F_ALPHA_CALL_SHARED;
1950   else if ((abfd->flags & DYNAMIC) != 0)
1951     fhdr->f_flags |= F_ALPHA_SHARABLE;
1952   return true;
1953 }
1954 \f
1955 /* This is the ECOFF backend structure.  The backend field of the
1956    target vector points to this.  */
1957
1958 static const struct ecoff_backend_data alpha_ecoff_backend_data =
1959 {
1960   /* COFF backend structure.  */
1961   {
1962     (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1963     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1964     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1965     (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1966     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1967     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1968     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1969     alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
1970     alpha_ecoff_swap_scnhdr_out,
1971     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, true,
1972     alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
1973     alpha_ecoff_swap_scnhdr_in, NULL,
1974     alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1975     alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1976     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1977     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
1978   },
1979   /* Supported architecture.  */
1980   bfd_arch_alpha,
1981   /* Initial portion of armap string.  */
1982   "________64",
1983   /* The page boundary used to align sections in a demand-paged
1984      executable file.  E.g., 0x1000.  */
1985   0x2000,
1986   /* True if the .rdata section is part of the text segment, as on the
1987      Alpha.  False if .rdata is part of the data segment, as on the
1988      MIPS.  */
1989   true,
1990   /* Bitsize of constructor entries.  */
1991   64,
1992   /* Reloc to use for constructor entries.  */
1993   &alpha_howto_table[ALPHA_R_REFQUAD],
1994   {
1995     /* Symbol table magic number.  */
1996     magicSym2,
1997     /* Alignment of debugging information.  E.g., 4.  */
1998     8,
1999     /* Sizes of external symbolic information.  */
2000     sizeof (struct hdr_ext),
2001     sizeof (struct dnr_ext),
2002     sizeof (struct pdr_ext),
2003     sizeof (struct sym_ext),
2004     sizeof (struct opt_ext),
2005     sizeof (struct fdr_ext),
2006     sizeof (struct rfd_ext),
2007     sizeof (struct ext_ext),
2008     /* Functions to swap in external symbolic data.  */
2009     ecoff_swap_hdr_in,
2010     ecoff_swap_dnr_in,
2011     ecoff_swap_pdr_in,
2012     ecoff_swap_sym_in,
2013     ecoff_swap_opt_in,
2014     ecoff_swap_fdr_in,
2015     ecoff_swap_rfd_in,
2016     ecoff_swap_ext_in,
2017     _bfd_ecoff_swap_tir_in,
2018     _bfd_ecoff_swap_rndx_in,
2019     /* Functions to swap out external symbolic data.  */
2020     ecoff_swap_hdr_out,
2021     ecoff_swap_dnr_out,
2022     ecoff_swap_pdr_out,
2023     ecoff_swap_sym_out,
2024     ecoff_swap_opt_out,
2025     ecoff_swap_fdr_out,
2026     ecoff_swap_rfd_out,
2027     ecoff_swap_ext_out,
2028     _bfd_ecoff_swap_tir_out,
2029     _bfd_ecoff_swap_rndx_out,
2030     /* Function to read in symbolic data.  */
2031     _bfd_ecoff_slurp_symbolic_info
2032   },
2033   /* External reloc size.  */
2034   RELSZ,
2035   /* Reloc swapping functions.  */
2036   alpha_ecoff_swap_reloc_in,
2037   alpha_ecoff_swap_reloc_out,
2038   /* Backend reloc tweaking.  */
2039   alpha_adjust_reloc_in,
2040   alpha_adjust_reloc_out,
2041   /* Relocate section contents while linking.  */
2042   alpha_relocate_section,
2043   /* Do final adjustments to filehdr and aouthdr.  */
2044   alpha_adjust_headers
2045 };
2046
2047 /* Looking up a reloc type is Alpha specific.  */
2048 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2049
2050 /* So is getting relocated section contents.  */
2051 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2052   alpha_ecoff_get_relocated_section_contents
2053
2054 /* Handling file windows is generic.  */
2055 #define _bfd_ecoff_get_section_contents_in_window \
2056   _bfd_generic_get_section_contents_in_window
2057
2058 /* Relaxing sections is generic.  */
2059 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2060
2061 const bfd_target ecoffalpha_little_vec =
2062 {
2063   "ecoff-littlealpha",          /* name */
2064   bfd_target_ecoff_flavour,
2065   false,                        /* data byte order is little */
2066   false,                        /* header byte order is little */
2067
2068   (HAS_RELOC | EXEC_P |         /* object flags */
2069    HAS_LINENO | HAS_DEBUG |
2070    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2071
2072   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2073   0,                            /* leading underscore */
2074   ' ',                          /* ar_pad_char */
2075   15,                           /* ar_max_namelen */
2076   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2077      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2078      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2079   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2080      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2081      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2082
2083   {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2084      _bfd_ecoff_archive_p, _bfd_dummy_target},
2085   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2086      _bfd_generic_mkarchive, bfd_false},
2087   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2088      _bfd_write_archive_contents, bfd_false},
2089
2090      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2091      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2092      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2093      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2094      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2095      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2096      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2097      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2098      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2099
2100   (PTR) &alpha_ecoff_backend_data
2101 };