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_NONE
 557            || intern->r_symndx == RELOC_SECTION_ABS))
 558         abort ();
 559       if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
 560         intern->r_symndx = RELOC_SECTION_NONE;
 561     }
 562 }
 563
 564 /* Swap a reloc out.  */
 565
 566 static void
 567 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
 568      bfd *abfd;
 569      const struct internal_reloc *intern;
 570      PTR dst;
 571 {
 572   RELOC *ext = (RELOC *) dst;
 573   long symndx;
 574   unsigned char size;
 575
 576   /* Undo the hackery done in swap_reloc_in.  */
 577   if (intern->r_type == ALPHA_R_LITUSE
 578       || intern->r_type == ALPHA_R_GPDISP)
 579     {
 580       symndx = intern->r_size;
 581       size = 0;
 582     }
 583   else if (intern->r_type == ALPHA_R_IGNORE
 584            && ! intern->r_extern
 585            && intern->r_symndx == RELOC_SECTION_NONE)
 586     {
 587       symndx = RELOC_SECTION_LITA;
 588       size = intern->r_size;
 589     }
 590   else
 591     {
 592       symndx = intern->r_symndx;
 593       size = intern->r_size;
 594     }
 595
 596   BFD_ASSERT (intern->r_extern
 597               || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
 598
 599   bfd_h_put_64 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
 600   bfd_h_put_32 (abfd, symndx, (bfd_byte *) ext->r_symndx);
 601
 602   BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
 603
 604   ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
 605                     & RELOC_BITS0_TYPE_LITTLE);
 606   ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
 607                     | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
 608                        & RELOC_BITS1_OFFSET_LITTLE));
 609   ext->r_bits[2] = 0;
 610   ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
 611                     & RELOC_BITS3_SIZE_LITTLE);
 612 }
 613
 614 /* Finish canonicalizing a reloc.  Part of this is generic to all
 615    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 616    this backend routine.  It must fill in the howto field.  */
 617
 618 static void
 619 alpha_adjust_reloc_in (abfd, intern, rptr)
 620      bfd *abfd;
 621      const struct internal_reloc *intern;
 622      arelent *rptr;
 623 {
 624   if (intern->r_type > ALPHA_R_GPVALUE)
 625     abort ();
 626
 627   switch (intern->r_type)
 628     {
 629     case ALPHA_R_BRADDR:
 630     case ALPHA_R_SREL16:
 631     case ALPHA_R_SREL32:
 632     case ALPHA_R_SREL64:
 633       /* The PC relative relocs do not seem to use the section VMA as
 634          a negative addend.  */
 635       rptr->addend = 0;
 636       break;
 637
 638     case ALPHA_R_GPREL32:
 639     case ALPHA_R_LITERAL:
 640       /* Copy the gp value for this object file into the addend, to
 641          ensure that we are not confused by the linker.  */
 642       if (! intern->r_extern)
 643         rptr->addend += ecoff_data (abfd)->gp;
 644       break;
 645
 646     case ALPHA_R_LITUSE:
 647     case ALPHA_R_GPDISP:
 648       /* The LITUSE and GPDISP relocs do not use a symbol, or an
 649          addend, but they do use a special code.  Put this code in the
 650          addend field.  */
 651       rptr->addend = intern->r_size;
 652       break;
 653
 654     case ALPHA_R_OP_STORE:
 655       /* The STORE reloc needs the size and offset fields.  We store
 656          them in the addend.  */
 657       BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
 658       rptr->addend = (intern->r_offset << 8) + intern->r_size;
 659       break;
 660
 661     case ALPHA_R_OP_PUSH:
 662     case ALPHA_R_OP_PSUB:
 663     case ALPHA_R_OP_PRSHIFT:
 664       /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
 665          address.  I believe that the address supplied is really an
 666          addend.  */
 667       rptr->addend = intern->r_vaddr;
 668       break;
 669
 670     case ALPHA_R_GPVALUE:
 671       /* Set the addend field to the new GP value.  */
 672       rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
 673       break;
 674
 675     case ALPHA_R_IGNORE:
 676       /* If the type is ALPHA_R_IGNORE, make sure this is a reference
 677          to the absolute section so that the reloc is ignored.  For
 678          some reason the address of this reloc type is not adjusted by
 679          the section vma.  We record the gp value for this object file
 680          here, for convenience when doing the GPDISP relocation.  */
 681       rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 682       rptr->address = intern->r_vaddr;
 683       rptr->addend = ecoff_data (abfd)->gp;
 684       break;
 685
 686     default:
 687       break;
 688     }
 689
 690   rptr->howto = &alpha_howto_table[intern->r_type];
 691 }
 692
 693 /* When writing out a reloc we need to pull some values back out of
 694    the addend field into the reloc.  This is roughly the reverse of
 695    alpha_adjust_reloc_in, except that there are several changes we do
 696    not need to undo.  */
 697
 698 static void
 699 alpha_adjust_reloc_out (abfd, rel, intern)
 700      bfd *abfd;
 701      const arelent *rel;
 702      struct internal_reloc *intern;
 703 {
 704   switch (intern->r_type)
 705     {
 706     case ALPHA_R_LITUSE:
 707     case ALPHA_R_GPDISP:
 708       intern->r_size = rel->addend;
 709       break;
 710
 711     case ALPHA_R_OP_STORE:
 712       intern->r_size = rel->addend & 0xff;
 713       intern->r_offset = (rel->addend >> 8) & 0xff;
 714       break;
 715
 716     case ALPHA_R_OP_PUSH:
 717     case ALPHA_R_OP_PSUB:
 718     case ALPHA_R_OP_PRSHIFT:
 719       intern->r_vaddr = rel->addend;
 720       break;
 721
 722     case ALPHA_R_IGNORE:
 723       intern->r_vaddr = rel->address;
 724       if (intern->r_symndx == RELOC_SECTION_ABS)
 725         intern->r_symndx = RELOC_SECTION_NONE;
 726       break;
 727
 728     default:
 729       break;
 730     }
 731 }
 732
 733 /* The size of the stack for the relocation evaluator.  */
 734 #define RELOC_STACKSIZE (10)
 735
 736 /* Alpha ECOFF relocs have a built in expression evaluator as well as
 737    other interdependencies.  Rather than use a bunch of special
 738    functions and global variables, we use a single routine to do all
 739    the relocation for a section.  I haven't yet worked out how the
 740    assembler is going to handle this.  */
 741
 742 static bfd_byte *
 743 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
 744                                             data, relocateable, symbols)
 745      bfd *abfd;
 746      struct bfd_link_info *link_info;
 747      struct bfd_link_order *link_order;
 748      bfd_byte *data;
 749      boolean relocateable;
 750      asymbol **symbols;
 751 {
 752   bfd *input_bfd = link_order->u.indirect.section->owner;
 753   asection *input_section = link_order->u.indirect.section;
 754   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
 755   arelent **reloc_vector = NULL;
 756   long reloc_count;
 757   bfd *output_bfd = relocateable ? abfd : (bfd *) NULL;
 758   bfd_vma gp;
 759   boolean gp_undefined;
 760   bfd_vma stack[RELOC_STACKSIZE];
 761   int tos = 0;
 762
 763   if (reloc_size < 0)
 764     goto error_return;
 765   reloc_vector = (arelent **) malloc (reloc_size);
 766   if (reloc_vector == NULL && reloc_size != 0)
 767     {
 768       bfd_set_error (bfd_error_no_memory);
 769       goto error_return;
 770     }
 771
 772   if (! bfd_get_section_contents (input_bfd, input_section, data,
 773                                   (file_ptr) 0, input_section->_raw_size))
 774     goto error_return;
 775
 776   /* The section size is not going to change.  */
 777   input_section->_cooked_size = input_section->_raw_size;
 778   input_section->reloc_done = true;
 779
 780   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
 781                                         reloc_vector, symbols);
 782   if (reloc_count < 0)
 783     goto error_return;
 784   if (reloc_count == 0)
 785     goto successful_return;
 786
 787   /* Get the GP value for the output BFD.  */
 788   gp_undefined = false;
 789   if (ecoff_data (abfd)->gp == 0)
 790     {
 791       if (relocateable != false)
 792         {
 793           asection *sec;
 794           bfd_vma lo;
 795
 796           /* Make up a value.  */
 797           lo = (bfd_vma) -1;
 798           for (sec = abfd->sections; sec != NULL; sec = sec->next)
 799             {
 800               if (sec->vma < lo
 801                   && (strcmp (sec->name, ".sbss") == 0
 802                       || strcmp (sec->name, ".sdata") == 0
 803                       || strcmp (sec->name, ".lit4") == 0
 804                       || strcmp (sec->name, ".lit8") == 0
 805                       || strcmp (sec->name, ".lita") == 0))
 806                 lo = sec->vma;
 807             }
 808           ecoff_data (abfd)->gp = lo + 0x8000;
 809         }
 810       else
 811         {
 812           struct bfd_link_hash_entry *h;
 813
 814           h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false,
 815                                     true);
 816           if (h == (struct bfd_link_hash_entry *) NULL
 817               || h->type != bfd_link_hash_defined)
 818             gp_undefined = true;
 819           else
 820             ecoff_data (abfd)->gp = (h->u.def.value
 821                                      + h->u.def.section->output_section->vma
 822                                      + h->u.def.section->output_offset);
 823         }
 824     }
 825   gp = ecoff_data (abfd)->gp;
 826
 827   for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
 828     {
 829       arelent *rel;
 830       bfd_reloc_status_type r;
 831       char *err;
 832
 833       rel = *reloc_vector;
 834       r = bfd_reloc_ok;
 835       switch (rel->howto->type)
 836         {
 837         case ALPHA_R_IGNORE:
 838           rel->address += input_section->output_offset;
 839           break;
 840
 841         case ALPHA_R_REFLONG:
 842         case ALPHA_R_REFQUAD:
 843         case ALPHA_R_BRADDR:
 844         case ALPHA_R_HINT:
 845         case ALPHA_R_SREL16:
 846         case ALPHA_R_SREL32:
 847         case ALPHA_R_SREL64:
 848           if (relocateable
 849               && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
 850             {
 851               rel->address += input_section->output_offset;
 852               break;
 853             }
 854           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 855                                       output_bfd, &err);
 856           break;
 857
 858         case ALPHA_R_GPREL32:
 859           /* This relocation is used in a switch table.  It is a 32
 860              bit offset from the current GP value.  We must adjust it
 861              by the different between the original GP value and the
 862              current GP value.  The original GP value is stored in the
 863              addend.  We adjust the addend and let
 864              bfd_perform_relocation finish the job.  */
 865           rel->addend -= gp;
 866           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 867                                       output_bfd, &err);
 868           if (r == bfd_reloc_ok && gp_undefined)
 869             {
 870               r = bfd_reloc_dangerous;
 871               err = (char *) "GP relative relocation used when GP not defined";
 872             }
 873           break;
 874
 875         case ALPHA_R_LITERAL:
 876           /* This is a reference to a literal value, generally
 877              (always?) in the .lita section.  This is a 16 bit GP
 878              relative relocation.  Sometimes the subsequent reloc is a
 879              LITUSE reloc, which indicates how this reloc is used.
 880              This sometimes permits rewriting the two instructions
 881              referred to by the LITERAL and the LITUSE into different
 882              instructions which do not refer to .lita.  This can save
 883              a memory reference, and permits removing a value from
 884              .lita thus saving GP relative space.
 885
 886              We do not these optimizations.  To do them we would need
 887              to arrange to link the .lita section first, so that by
 888              the time we got here we would know the final values to
 889              use.  This would not be particularly difficult, but it is
 890              not currently implemented.  */
 891
 892           {
 893             unsigned long insn;
 894
 895             /* I believe that the LITERAL reloc will only apply to a
 896                ldq or ldl instruction, so check my assumption.  */
 897             insn = bfd_get_32 (input_bfd, data + rel->address);
 898             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
 899                         || ((insn >> 26) & 0x3f) == 0x28);
 900
 901             rel->addend -= gp;
 902             r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 903                                         output_bfd, &err);
 904             if (r == bfd_reloc_ok && gp_undefined)
 905               {
 906                 r = bfd_reloc_dangerous;
 907                 err =
 908                   (char *) "GP relative relocation used when GP not defined";
 909               }
 910           }
 911           break;
 912
 913         case ALPHA_R_LITUSE:
 914           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
 915              does not cause anything to happen, itself.  */
 916           rel->address += input_section->output_offset;
 917           break;
 918
 919         case ALPHA_R_GPDISP:
 920           /* This marks the ldah of an ldah/lda pair which loads the
 921              gp register with the difference of the gp value and the
 922              current location.  The second of the pair is r_size bytes
 923              ahead, and is marked with an ALPHA_R_IGNORE reloc.  */
 924           {
 925             unsigned long insn1, insn2;
 926             bfd_vma addend;
 927
 928             BFD_ASSERT (reloc_vector[1] != NULL
 929                         && reloc_vector[1]->howto->type == ALPHA_R_IGNORE
 930                         && (rel->address + rel->addend
 931                             == reloc_vector[1]->address));
 932
 933             /* Get the two instructions.  */
 934             insn1 = bfd_get_32 (input_bfd, data + rel->address);
 935             insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
 936
 937             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
 938             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
 939
 940             /* Get the existing addend.  We must account for the sign
 941                extension done by lda and ldah.  */
 942             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
 943             if (insn1 & 0x8000)
 944               {
 945                 addend -= 0x80000000;
 946                 addend -= 0x80000000;
 947               }
 948             if (insn2 & 0x8000)
 949               addend -= 0x10000;
 950
 951             /* The existing addend includes the different between the
 952                gp of the input BFD and the address in the input BFD.
 953                Subtract this out.  */
 954             addend -= (reloc_vector[1]->addend
 955                        - (input_section->vma + rel->address));
 956
 957             /* Now add in the final gp value, and subtract out the
 958                final address.  */
 959             addend += (gp
 960                        - (input_section->output_section->vma
 961                           + input_section->output_offset
 962                           + rel->address));
 963
 964             /* Change the instructions, accounting for the sign
 965                extension, and write them out.  */
 966             if (addend & 0x8000)
 967               addend += 0x10000;
 968             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
 969             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
 970
 971             bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
 972             bfd_put_32 (input_bfd, (bfd_vma) insn2,
 973                         data + rel->address + rel->addend);
 974
 975             rel->address += input_section->output_offset;
 976           }
 977           break;
 978
 979         case ALPHA_R_OP_PUSH:
 980           /* Push a value on the reloc evaluation stack.  */
 981           {
 982             asymbol *symbol;
 983             bfd_vma relocation;
 984
 985             if (relocateable)
 986               {
 987                 rel->address += input_section->output_offset;
 988                 break;
 989               }
 990
 991             /* Figure out the relocation of this symbol.  */
 992             symbol = *rel->sym_ptr_ptr;
 993
 994             if (bfd_is_und_section (symbol->section))
 995               r = bfd_reloc_undefined;
 996
 997             if (bfd_is_com_section (symbol->section))
 998               relocation = 0;
 999             else
1000               relocation = symbol->value;
1001             relocation += symbol->section->output_section->vma;
1002             relocation += symbol->section->output_offset;
1003             relocation += rel->addend;
1004
1005             if (tos >= RELOC_STACKSIZE)
1006               abort ();
1007
1008             stack[tos++] = relocation;
1009           }
1010           break;
1011
1012         case ALPHA_R_OP_STORE:
1013           /* Store a value from the reloc stack into a bitfield.  */
1014           {
1015             bfd_vma val;
1016             int offset, size;
1017
1018             if (relocateable)
1019               {
1020                 rel->address += input_section->output_offset;
1021                 break;
1022               }
1023
1024             if (tos == 0)
1025               abort ();
1026
1027             /* The offset and size for this reloc are encoded into the
1028                addend field by alpha_adjust_reloc_in.  */
1029             offset = (rel->addend >> 8) & 0xff;
1030             size = rel->addend & 0xff;
1031
1032             val = bfd_get_64 (abfd, data + rel->address);
1033             val &=~ (((1 << size) - 1) << offset);
1034             val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1035             bfd_put_64 (abfd, val, data + rel->address);
1036           }
1037           break;
1038
1039         case ALPHA_R_OP_PSUB:
1040           /* Subtract a value from the top of the stack.  */
1041           {
1042             asymbol *symbol;
1043             bfd_vma relocation;
1044
1045             if (relocateable)
1046               {
1047                 rel->address += input_section->output_offset;
1048                 break;
1049               }
1050
1051             /* Figure out the relocation of this symbol.  */
1052             symbol = *rel->sym_ptr_ptr;
1053
1054             if (bfd_is_und_section (symbol->section))
1055               r = bfd_reloc_undefined;
1056
1057             if (bfd_is_com_section (symbol->section))
1058               relocation = 0;
1059             else
1060               relocation = symbol->value;
1061             relocation += symbol->section->output_section->vma;
1062             relocation += symbol->section->output_offset;
1063             relocation += rel->addend;
1064
1065             if (tos == 0)
1066               abort ();
1067
1068             stack[tos - 1] -= relocation;
1069           }
1070           break;
1071
1072         case ALPHA_R_OP_PRSHIFT:
1073           /* Shift the value on the top of the stack.  */
1074           {
1075             asymbol *symbol;
1076             bfd_vma relocation;
1077
1078             if (relocateable)
1079               {
1080                 rel->address += input_section->output_offset;
1081                 break;
1082               }
1083
1084             /* Figure out the relocation of this symbol.  */
1085             symbol = *rel->sym_ptr_ptr;
1086
1087             if (bfd_is_und_section (symbol->section))
1088               r = bfd_reloc_undefined;
1089
1090             if (bfd_is_com_section (symbol->section))
1091               relocation = 0;
1092             else
1093               relocation = symbol->value;
1094             relocation += symbol->section->output_section->vma;
1095             relocation += symbol->section->output_offset;
1096             relocation += rel->addend;
1097
1098             if (tos == 0)
1099               abort ();
1100
1101             stack[tos - 1] >>= relocation;
1102           }
1103           break;
1104
1105         case ALPHA_R_GPVALUE:
1106           /* I really don't know if this does the right thing.  */
1107           gp = rel->addend;
1108           gp_undefined = false;
1109           break;
1110
1111         default:
1112           abort ();
1113         }
1114
1115       if (relocateable)
1116         {
1117           asection *os = input_section->output_section;
1118
1119           /* A partial link, so keep the relocs.  */
1120           os->orelocation[os->reloc_count] = rel;
1121           os->reloc_count++;
1122         }
1123
1124       if (r != bfd_reloc_ok)
1125         {
1126           switch (r)
1127             {
1128             case bfd_reloc_undefined:
1129               if (! ((*link_info->callbacks->undefined_symbol)
1130                      (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1131                       input_bfd, input_section, rel->address)))
1132                 goto error_return;
1133               break;
1134             case bfd_reloc_dangerous:
1135               if (! ((*link_info->callbacks->reloc_dangerous)
1136                      (link_info, err, input_bfd, input_section,
1137                       rel->address)))
1138                 goto error_return;
1139               break;
1140             case bfd_reloc_overflow:
1141               if (! ((*link_info->callbacks->reloc_overflow)
1142                      (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1143                       rel->howto->name, rel->addend, input_bfd,
1144                       input_section, rel->address)))
1145                 goto error_return;
1146               break;
1147             case bfd_reloc_outofrange:
1148             default:
1149               abort ();
1150               break;
1151             }
1152         }
1153     }
1154
1155   if (tos != 0)
1156     abort ();
1157
1158  successful_return:
1159   if (reloc_vector != NULL)
1160     free (reloc_vector);
1161   return data;
1162
1163  error_return:
1164   if (reloc_vector != NULL)
1165     free (reloc_vector);
1166   return NULL;
1167 }
1168
1169 /* Get the howto structure for a generic reloc type.  */
1170
1171 static reloc_howto_type *
1172 alpha_bfd_reloc_type_lookup (abfd, code)
1173      bfd *abfd;
1174      bfd_reloc_code_real_type code;
1175 {
1176   int alpha_type;
1177
1178   switch (code)
1179     {
1180     case BFD_RELOC_32:
1181       alpha_type = ALPHA_R_REFLONG;
1182       break;
1183     case BFD_RELOC_64:
1184     case BFD_RELOC_CTOR:
1185       alpha_type = ALPHA_R_REFQUAD;
1186       break;
1187     case BFD_RELOC_GPREL32:
1188       alpha_type = ALPHA_R_GPREL32;
1189       break;
1190     case BFD_RELOC_ALPHA_LITERAL:
1191       alpha_type = ALPHA_R_LITERAL;
1192       break;
1193     case BFD_RELOC_ALPHA_LITUSE:
1194       alpha_type = ALPHA_R_LITUSE;
1195       break;
1196     case BFD_RELOC_ALPHA_GPDISP_HI16:
1197       alpha_type = ALPHA_R_GPDISP;
1198       break;
1199     case BFD_RELOC_ALPHA_GPDISP_LO16:
1200       alpha_type = ALPHA_R_IGNORE;
1201       break;
1202     case BFD_RELOC_23_PCREL_S2:
1203       alpha_type = ALPHA_R_BRADDR;
1204       break;
1205     case BFD_RELOC_ALPHA_HINT:
1206       alpha_type = ALPHA_R_HINT;
1207       break;
1208     case BFD_RELOC_16_PCREL:
1209       alpha_type = ALPHA_R_SREL16;
1210       break;
1211     case BFD_RELOC_32_PCREL:
1212       alpha_type = ALPHA_R_SREL32;
1213       break;
1214     case BFD_RELOC_64_PCREL:
1215       alpha_type = ALPHA_R_SREL64;
1216       break;
1217 #if 0
1218     case ???:
1219       alpha_type = ALPHA_R_OP_PUSH;
1220       break;
1221     case ???:
1222       alpha_type = ALPHA_R_OP_STORE;
1223       break;
1224     case ???:
1225       alpha_type = ALPHA_R_OP_PSUB;
1226       break;
1227     case ???:
1228       alpha_type = ALPHA_R_OP_PRSHIFT;
1229       break;
1230     case ???:
1231       alpha_type = ALPHA_R_GPVALUE;
1232       break;
1233 #endif
1234     default:
1235       return (reloc_howto_type *) NULL;
1236     }
1237
1238   return &alpha_howto_table[alpha_type];
1239 }
1240 \f
1241 /* A helper routine for alpha_relocate_section which converts an
1242    external reloc when generating relocateable output.  Returns the
1243    relocation amount.  */
1244
1245 static bfd_vma
1246 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1247      bfd *output_bfd;
1248      struct bfd_link_info *info;
1249      bfd *input_bfd;
1250      struct external_reloc *ext_rel;
1251      struct ecoff_link_hash_entry *h;
1252 {
1253   unsigned long r_symndx;
1254   bfd_vma relocation;
1255
1256   BFD_ASSERT (info->relocateable);
1257
1258   if (h->root.type == bfd_link_hash_defined
1259       || h->root.type == bfd_link_hash_defweak)
1260     {
1261       asection *hsec;
1262       const char *name;
1263
1264       /* This symbol is defined in the output.  Convert the reloc from
1265          being against the symbol to being against the section.  */
1266
1267       /* Clear the r_extern bit.  */
1268       ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1269
1270       /* Compute a new r_symndx value.  */
1271       hsec = h->root.u.def.section;
1272       name = bfd_get_section_name (output_bfd, hsec->output_section);
1273
1274       r_symndx = -1;
1275       switch (name[1])
1276         {
1277         case 'A':
1278           if (strcmp (name, "*ABS*") == 0)
1279             r_symndx = RELOC_SECTION_ABS;
1280           break;
1281         case 'b':
1282           if (strcmp (name, ".bss") == 0)
1283             r_symndx = RELOC_SECTION_BSS;
1284           break;
1285         case 'd':
1286           if (strcmp (name, ".data") == 0)
1287             r_symndx = RELOC_SECTION_DATA;
1288           break;
1289         case 'f':
1290           if (strcmp (name, ".fini") == 0)
1291             r_symndx = RELOC_SECTION_FINI;
1292           break;
1293         case 'i':
1294           if (strcmp (name, ".init") == 0)
1295             r_symndx = RELOC_SECTION_INIT;
1296           break;
1297         case 'l':
1298           if (strcmp (name, ".lita") == 0)
1299             r_symndx = RELOC_SECTION_LITA;
1300           else if (strcmp (name, ".lit8") == 0)
1301             r_symndx = RELOC_SECTION_LIT8;
1302           else if (strcmp (name, ".lit4") == 0)
1303             r_symndx = RELOC_SECTION_LIT4;
1304           break;
1305         case 'p':
1306           if (strcmp (name, ".pdata") == 0)
1307             r_symndx = RELOC_SECTION_PDATA;
1308           break;
1309         case 'r':
1310           if (strcmp (name, ".rdata") == 0)
1311             r_symndx = RELOC_SECTION_RDATA;
1312           break;
1313         case 's':
1314           if (strcmp (name, ".sdata") == 0)
1315             r_symndx = RELOC_SECTION_SDATA;
1316           else if (strcmp (name, ".sbss") == 0)
1317             r_symndx = RELOC_SECTION_SBSS;
1318           break;
1319         case 't':
1320           if (strcmp (name, ".text") == 0)
1321             r_symndx = RELOC_SECTION_TEXT;
1322           break;
1323         case 'x':
1324           if (strcmp (name, ".xdata") == 0)
1325             r_symndx = RELOC_SECTION_XDATA;
1326           break;
1327         }
1328
1329       if (r_symndx == -1)
1330         abort ();
1331
1332       /* Add the section VMA and the symbol value.  */
1333       relocation = (h->root.u.def.value
1334                     + hsec->output_section->vma
1335                     + hsec->output_offset);
1336     }
1337   else
1338     {
1339       /* Change the symndx value to the right one for
1340          the output BFD.  */
1341       r_symndx = h->indx;
1342       if (r_symndx == -1)
1343         {
1344           /* Caller must give an error.  */
1345           r_symndx = 0;
1346         }
1347       relocation = 0;
1348     }
1349
1350   /* Write out the new r_symndx value.  */
1351   bfd_h_put_32 (input_bfd, (bfd_vma) r_symndx,
1352                 (bfd_byte *) ext_rel->r_symndx);
1353
1354   return relocation;
1355 }
1356
1357 /* Relocate a section while linking an Alpha ECOFF file.  This is
1358    quite similar to get_relocated_section_contents.  Perhaps they
1359    could be combined somehow.  */
1360
1361 static boolean
1362 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1363                         contents, external_relocs)
1364      bfd *output_bfd;
1365      struct bfd_link_info *info;
1366      bfd *input_bfd;
1367      asection *input_section;
1368      bfd_byte *contents;
1369      PTR external_relocs;
1370 {
1371   asection **symndx_to_section;
1372   struct ecoff_link_hash_entry **sym_hashes;
1373   bfd_vma gp;
1374   boolean gp_undefined;
1375   bfd_vma stack[RELOC_STACKSIZE];
1376   int tos = 0;
1377   struct external_reloc *ext_rel;
1378   struct external_reloc *ext_rel_end;
1379
1380   /* We keep a table mapping the symndx found in an internal reloc to
1381      the appropriate section.  This is faster than looking up the
1382      section by name each time.  */
1383   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1384   if (symndx_to_section == (asection **) NULL)
1385     {
1386       symndx_to_section = ((asection **)
1387                            bfd_alloc (input_bfd,
1388                                       (NUM_RELOC_SECTIONS
1389                                        * sizeof (asection *))));
1390       if (!symndx_to_section)
1391         {
1392           bfd_set_error (bfd_error_no_memory);
1393           return false;
1394         }
1395
1396       symndx_to_section[RELOC_SECTION_NONE] = NULL;
1397       symndx_to_section[RELOC_SECTION_TEXT] =
1398         bfd_get_section_by_name (input_bfd, ".text");
1399       symndx_to_section[RELOC_SECTION_RDATA] =
1400         bfd_get_section_by_name (input_bfd, ".rdata");
1401       symndx_to_section[RELOC_SECTION_DATA] =
1402         bfd_get_section_by_name (input_bfd, ".data");
1403       symndx_to_section[RELOC_SECTION_SDATA] =
1404         bfd_get_section_by_name (input_bfd, ".sdata");
1405       symndx_to_section[RELOC_SECTION_SBSS] =
1406         bfd_get_section_by_name (input_bfd, ".sbss");
1407       symndx_to_section[RELOC_SECTION_BSS] =
1408         bfd_get_section_by_name (input_bfd, ".bss");
1409       symndx_to_section[RELOC_SECTION_INIT] =
1410         bfd_get_section_by_name (input_bfd, ".init");
1411       symndx_to_section[RELOC_SECTION_LIT8] =
1412         bfd_get_section_by_name (input_bfd, ".lit8");
1413       symndx_to_section[RELOC_SECTION_LIT4] =
1414         bfd_get_section_by_name (input_bfd, ".lit4");
1415       symndx_to_section[RELOC_SECTION_XDATA] =
1416         bfd_get_section_by_name (input_bfd, ".xdata");
1417       symndx_to_section[RELOC_SECTION_PDATA] =
1418         bfd_get_section_by_name (input_bfd, ".pdata");
1419       symndx_to_section[RELOC_SECTION_FINI] =
1420         bfd_get_section_by_name (input_bfd, ".fini");
1421       symndx_to_section[RELOC_SECTION_LITA] =
1422         bfd_get_section_by_name (input_bfd, ".lita");
1423       symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1424
1425       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1426     }
1427
1428   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1429
1430   gp = ecoff_data (output_bfd)->gp;
1431   if (gp == 0)
1432     gp_undefined = true;
1433   else
1434     gp_undefined = false;
1435
1436   BFD_ASSERT (output_bfd->xvec->header_byteorder_big_p == false);
1437   BFD_ASSERT (input_bfd->xvec->header_byteorder_big_p == false);
1438
1439   ext_rel = (struct external_reloc *) external_relocs;
1440   ext_rel_end = ext_rel + input_section->reloc_count;
1441   for (; ext_rel < ext_rel_end; ext_rel++)
1442     {
1443       bfd_vma r_vaddr;
1444       unsigned long r_symndx;
1445       int r_type;
1446       int r_extern;
1447       int r_offset;
1448       int r_size;
1449       boolean relocatep;
1450       boolean adjust_addrp;
1451       boolean gp_usedp;
1452       bfd_vma addend;
1453
1454       r_vaddr = bfd_h_get_64 (input_bfd, (bfd_byte *) ext_rel->r_vaddr);
1455       r_symndx = bfd_h_get_32 (input_bfd, (bfd_byte *) ext_rel->r_symndx);
1456
1457       r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1458                 >> RELOC_BITS0_TYPE_SH_LITTLE);
1459       r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1460       r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1461                   >> RELOC_BITS1_OFFSET_SH_LITTLE);
1462       /* Ignored the reserved bits.  */
1463       r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1464                 >> RELOC_BITS3_SIZE_SH_LITTLE);
1465
1466       relocatep = false;
1467       adjust_addrp = true;
1468       gp_usedp = false;
1469       addend = 0;
1470
1471       switch (r_type)
1472         {
1473         default:
1474           abort ();
1475
1476         case ALPHA_R_IGNORE:
1477           /* This reloc appears after a GPDISP reloc.  It marks the
1478              position of the second instruction to be altered by the
1479              GPDISP reloc, but is not otherwise used for anything.
1480              For some reason, the address of the relocation does not
1481              appear to include the section VMA, unlike the other
1482              relocation types.  */
1483           if (info->relocateable)
1484             bfd_h_put_64 (input_bfd,
1485                           input_section->output_offset + r_vaddr,
1486                           (bfd_byte *) ext_rel->r_vaddr);
1487           adjust_addrp = false;
1488           break;
1489
1490         case ALPHA_R_REFLONG:
1491         case ALPHA_R_REFQUAD:
1492         case ALPHA_R_BRADDR:
1493         case ALPHA_R_HINT:
1494         case ALPHA_R_SREL16:
1495         case ALPHA_R_SREL32:
1496         case ALPHA_R_SREL64:
1497           relocatep = true;
1498           break;
1499
1500         case ALPHA_R_GPREL32:
1501           /* This relocation is used in a switch table.  It is a 32
1502              bit offset from the current GP value.  We must adjust it
1503              by the different between the original GP value and the
1504              current GP value.  */
1505           relocatep = true;
1506           addend = ecoff_data (input_bfd)->gp - gp;
1507           gp_usedp = true;
1508           break;
1509
1510         case ALPHA_R_LITERAL:
1511           /* This is a reference to a literal value, generally
1512              (always?) in the .lita section.  This is a 16 bit GP
1513              relative relocation.  Sometimes the subsequent reloc is a
1514              LITUSE reloc, which indicates how this reloc is used.
1515              This sometimes permits rewriting the two instructions
1516              referred to by the LITERAL and the LITUSE into different
1517              instructions which do not refer to .lita.  This can save
1518              a memory reference, and permits removing a value from
1519              .lita thus saving GP relative space.
1520
1521              We do not these optimizations.  To do them we would need
1522              to arrange to link the .lita section first, so that by
1523              the time we got here we would know the final values to
1524              use.  This would not be particularly difficult, but it is
1525              not currently implemented.  */
1526
1527           /* I believe that the LITERAL reloc will only apply to a ldq
1528              or ldl instruction, so check my assumption.  */
1529           {
1530             unsigned long insn;
1531
1532             insn = bfd_get_32 (input_bfd,
1533                                contents + r_vaddr - input_section->vma);
1534             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1535                         || ((insn >> 26) & 0x3f) == 0x28);
1536           }
1537
1538           relocatep = true;
1539           addend = ecoff_data (input_bfd)->gp - gp;
1540           gp_usedp = true;
1541           break;
1542
1543         case ALPHA_R_LITUSE:
1544           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
1545              does not cause anything to happen, itself.  */
1546           break;
1547
1548         case ALPHA_R_GPDISP:
1549           /* This marks the ldah of an ldah/lda pair which loads the
1550              gp register with the difference of the gp value and the
1551              current location.  The second of the pair is r_symndx
1552              bytes ahead, and is also marked with an ALPHA_R_IGNORE
1553              reloc.  */
1554           {
1555             unsigned long insn1, insn2;
1556
1557             BFD_ASSERT (ext_rel + 1 < ext_rel_end
1558                         && (((ext_rel + 1)->r_bits[0]
1559                              & RELOC_BITS0_TYPE_LITTLE)
1560                             >> RELOC_BITS0_TYPE_SH_LITTLE) == ALPHA_R_IGNORE
1561                         && (bfd_h_get_64 (input_bfd,
1562                                           (bfd_byte *) (ext_rel + 1)->r_vaddr)
1563                             == r_vaddr - input_section->vma + r_symndx));
1564
1565             /* Get the two instructions.  */
1566             insn1 = bfd_get_32 (input_bfd,
1567                                 contents + r_vaddr - input_section->vma);
1568             insn2 = bfd_get_32 (input_bfd,
1569                                 (contents
1570                                  + r_vaddr
1571                                  - input_section->vma
1572                                  + r_symndx));
1573
1574             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1575             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1576
1577             /* Get the existing addend.  We must account for the sign
1578                extension done by lda and ldah.  */
1579             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1580             if (insn1 & 0x8000)
1581               {
1582                 /* This is addend -= 0x100000000 without causing an
1583                    integer overflow on a 32 bit host.  */
1584                 addend -= 0x80000000;
1585                 addend -= 0x80000000;
1586               }
1587             if (insn2 & 0x8000)
1588               addend -= 0x10000;
1589
1590             /* The existing addend includes the difference between the
1591                gp of the input BFD and the address in the input BFD.
1592                We want to change this to the difference between the
1593                final GP and the final address.  */
1594             addend += (gp
1595                        - ecoff_data (input_bfd)->gp
1596                        + input_section->vma
1597                        - (input_section->output_section->vma
1598                           + input_section->output_offset));
1599
1600             /* Change the instructions, accounting for the sign
1601                extension, and write them out.  */
1602             if (addend & 0x8000)
1603               addend += 0x10000;
1604             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1605             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1606
1607             bfd_put_32 (input_bfd, (bfd_vma) insn1,
1608                         contents + r_vaddr - input_section->vma);
1609             bfd_put_32 (input_bfd, (bfd_vma) insn2,
1610                         contents + r_vaddr - input_section->vma + r_symndx);
1611
1612             gp_usedp = true;
1613           }
1614           break;
1615
1616         case ALPHA_R_OP_PUSH:
1617         case ALPHA_R_OP_PSUB:
1618         case ALPHA_R_OP_PRSHIFT:
1619           /* Manipulate values on the reloc evaluation stack.  The
1620              r_vaddr field is not an address in input_section, it is
1621              the current value (including any addend) of the object
1622              being used.  */
1623           if (! r_extern)
1624             {
1625               asection *s;
1626
1627               s = symndx_to_section[r_symndx];
1628               if (s == (asection *) NULL)
1629                 abort ();
1630               addend = s->output_section->vma + s->output_offset - s->vma;
1631             }
1632           else
1633             {
1634               struct ecoff_link_hash_entry *h;
1635
1636               h = sym_hashes[r_symndx];
1637               if (h == (struct ecoff_link_hash_entry *) NULL)
1638                 abort ();
1639
1640               if (! info->relocateable)
1641                 {
1642                   if (h->root.type == bfd_link_hash_defined
1643                       || h->root.type == bfd_link_hash_defweak)
1644                     addend = (h->root.u.def.value
1645                               + h->root.u.def.section->output_section->vma
1646                               + h->root.u.def.section->output_offset);
1647                   else
1648                     {
1649                       /* Note that we pass the address as 0, since we
1650                          do not have a meaningful number for the
1651                          location within the section that is being
1652                          relocated.  */
1653                       if (! ((*info->callbacks->undefined_symbol)
1654                              (info, h->root.root.string, input_bfd,
1655                               input_section, (bfd_vma) 0)))
1656                         return false;
1657                       addend = 0;
1658                     }
1659                 }
1660               else
1661                 {
1662                   if (h->root.type != bfd_link_hash_defined
1663                       && h->root.type != bfd_link_hash_defweak
1664                       && h->indx == -1)
1665                     {
1666                       /* This symbol is not being written out.  Pass
1667                          the address as 0, as with undefined_symbol,
1668                          above.  */
1669                       if (! ((*info->callbacks->unattached_reloc)
1670                              (info, h->root.root.string, input_bfd,
1671                               input_section, (bfd_vma) 0)))
1672                         return false;
1673                     }
1674
1675                   addend = alpha_convert_external_reloc (output_bfd, info,
1676                                                          input_bfd,
1677                                                          ext_rel, h);
1678                 }
1679             }
1680
1681           addend += r_vaddr;
1682
1683           if (info->relocateable)
1684             {
1685               /* Adjust r_vaddr by the addend.  */
1686               bfd_h_put_64 (input_bfd, addend,
1687                             (bfd_byte *) ext_rel->r_vaddr);
1688             }
1689           else
1690             {
1691               switch (r_type)
1692                 {
1693                 case ALPHA_R_OP_PUSH:
1694                   if (tos >= RELOC_STACKSIZE)
1695                     abort ();
1696                   stack[tos++] = addend;
1697                   break;
1698
1699                 case ALPHA_R_OP_PSUB:
1700                   if (tos == 0)
1701                     abort ();
1702                   stack[tos - 1] -= addend;
1703                   break;
1704
1705                 case ALPHA_R_OP_PRSHIFT:
1706                   if (tos == 0)
1707                     abort ();
1708                   stack[tos - 1] >>= addend;
1709                   break;
1710                 }
1711             }
1712
1713           adjust_addrp = false;
1714           break;
1715
1716         case ALPHA_R_OP_STORE:
1717           /* Store a value from the reloc stack into a bitfield.  If
1718              we are generating relocateable output, all we do is
1719              adjust the address of the reloc.  */
1720           if (! info->relocateable)
1721             {
1722               bfd_vma mask;
1723               bfd_vma val;
1724
1725               if (tos == 0)
1726                 abort ();
1727
1728               /* Get the relocation mask.  The separate steps and the
1729                  casts to bfd_vma are attempts to avoid a bug in the
1730                  Alpha OSF 1.3 C compiler.  See reloc.c for more
1731                  details.  */
1732               mask = 1;
1733               mask <<= (bfd_vma) r_size;
1734               mask -= 1;
1735
1736               /* FIXME: I don't know what kind of overflow checking,
1737                  if any, should be done here.  */
1738               val = bfd_get_64 (input_bfd,
1739                                 contents + r_vaddr - input_section->vma);
1740               val &=~ mask << (bfd_vma) r_offset;
1741               val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1742               bfd_put_64 (input_bfd, val,
1743                           contents + r_vaddr - input_section->vma);
1744             }
1745           break;
1746
1747         case ALPHA_R_GPVALUE:
1748           /* I really don't know if this does the right thing.  */
1749           gp = ecoff_data (input_bfd)->gp + r_symndx;
1750           gp_undefined = false;
1751           break;
1752         }
1753
1754       if (relocatep)
1755         {
1756           reloc_howto_type *howto;
1757           struct ecoff_link_hash_entry *h = NULL;
1758           asection *s = NULL;
1759           bfd_vma relocation;
1760           bfd_reloc_status_type r;
1761
1762           /* Perform a relocation.  */
1763
1764           howto = &alpha_howto_table[r_type];
1765
1766           if (r_extern)
1767             {
1768               h = sym_hashes[r_symndx];
1769               /* If h is NULL, that means that there is a reloc
1770                  against an external symbol which we thought was just
1771                  a debugging symbol.  This should not happen.  */
1772               if (h == (struct ecoff_link_hash_entry *) NULL)
1773                 abort ();
1774             }
1775           else
1776             {
1777               if (r_symndx >= NUM_RELOC_SECTIONS)
1778                 s = NULL;
1779               else
1780                 s = symndx_to_section[r_symndx];
1781
1782               if (s == (asection *) NULL)
1783                 abort ();
1784             }
1785
1786           if (info->relocateable)
1787             {
1788               /* We are generating relocateable output, and must
1789                  convert the existing reloc.  */
1790               if (r_extern)
1791                 {
1792                   if (h->root.type != bfd_link_hash_defined
1793                       && h->root.type != bfd_link_hash_defweak
1794                       && h->indx == -1)
1795                     {
1796                       /* This symbol is not being written out.  */
1797                       if (! ((*info->callbacks->unattached_reloc)
1798                              (info, h->root.root.string, input_bfd,
1799                               input_section, r_vaddr - input_section->vma)))
1800                         return false;
1801                     }
1802
1803                   relocation = alpha_convert_external_reloc (output_bfd,
1804                                                              info,
1805                                                              input_bfd,
1806                                                              ext_rel,
1807                                                              h);
1808                 }
1809               else
1810                 {
1811                   /* This is a relocation against a section.  Adjust
1812                      the value by the amount the section moved.  */
1813                   relocation = (s->output_section->vma
1814                                 + s->output_offset
1815                                 - s->vma);
1816                 }
1817
1818               /* If this is PC relative, the existing object file
1819                  appears to already have the reloc worked out.  We
1820                  must subtract out the old value and add in the new
1821                  one.  */
1822               if (howto->pc_relative)
1823                 relocation -= (input_section->output_section->vma
1824                                + input_section->output_offset
1825                                - input_section->vma);
1826
1827               /* Put in any addend.  */
1828               relocation += addend;
1829
1830               /* Adjust the contents.  */
1831               r = _bfd_relocate_contents (howto, input_bfd, relocation,
1832                                           (contents
1833                                            + r_vaddr
1834                                            - input_section->vma));
1835             }
1836           else
1837             {
1838               /* We are producing a final executable.  */
1839               if (r_extern)
1840                 {
1841                   /* This is a reloc against a symbol.  */
1842                   if (h->root.type == bfd_link_hash_defined
1843                       || h->root.type == bfd_link_hash_defweak)
1844                     {
1845                       asection *hsec;
1846
1847                       hsec = h->root.u.def.section;
1848                       relocation = (h->root.u.def.value
1849                                     + hsec->output_section->vma
1850                                     + hsec->output_offset);
1851                     }
1852                   else
1853                     {
1854                       if (! ((*info->callbacks->undefined_symbol)
1855                              (info, h->root.root.string, input_bfd,
1856                               input_section,
1857                               r_vaddr - input_section->vma)))
1858                         return false;
1859                       relocation = 0;
1860                     }
1861                 }
1862               else
1863                 {
1864                   /* This is a reloc against a section.  */
1865                   relocation = (s->output_section->vma
1866                                 + s->output_offset
1867                                 - s->vma);
1868
1869                   /* Adjust a PC relative relocation by removing the
1870                      reference to the original source section.  */
1871                   if (howto->pc_relative)
1872                     relocation += input_section->vma;
1873                 }
1874
1875               r = _bfd_final_link_relocate (howto,
1876                                             input_bfd,
1877                                             input_section,
1878                                             contents,
1879                                             r_vaddr - input_section->vma,
1880                                             relocation,
1881                                             addend);
1882             }
1883
1884           if (r != bfd_reloc_ok)
1885             {
1886               switch (r)
1887                 {
1888                 default:
1889                 case bfd_reloc_outofrange:
1890                   abort ();
1891                 case bfd_reloc_overflow:
1892                   {
1893                     const char *name;
1894
1895                     if (r_extern)
1896                       name = sym_hashes[r_symndx]->root.root.string;
1897                     else
1898                       name = bfd_section_name (input_bfd,
1899                                                symndx_to_section[r_symndx]);
1900                     if (! ((*info->callbacks->reloc_overflow)
1901                            (info, name, alpha_howto_table[r_type].name,
1902                             (bfd_vma) 0, input_bfd, input_section,
1903                             r_vaddr - input_section->vma)))
1904                       return false;
1905                   }
1906                   break;
1907                 }
1908             }
1909         }
1910
1911       if (info->relocateable && adjust_addrp)
1912         {
1913           /* Change the address of the relocation.  */
1914           bfd_h_put_64 (input_bfd,
1915                         (input_section->output_section->vma
1916                          + input_section->output_offset
1917                          - input_section->vma
1918                          + r_vaddr),
1919                         (bfd_byte *) ext_rel->r_vaddr);
1920         }
1921
1922       if (gp_usedp && gp_undefined)
1923         {
1924           if (! ((*info->callbacks->reloc_dangerous)
1925                  (info, "GP relative relocation when GP not defined",
1926                   input_bfd, input_section, r_vaddr - input_section->vma)))
1927             return false;
1928           /* Only give the error once per link.  */
1929           ecoff_data (output_bfd)->gp = gp = 4;
1930           gp_undefined = false;
1931         }
1932     }
1933
1934   if (tos != 0)
1935     abort ();
1936
1937   return true;
1938 }
1939 \f
1940 /* Do final adjustments to the filehdr and the aouthdr.  This routine
1941    sets the dynamic bits in the file header.  */
1942
1943 /*ARGSUSED*/
1944 static boolean
1945 alpha_adjust_headers (abfd, fhdr, ahdr)
1946      bfd *abfd;
1947      struct internal_filehdr *fhdr;
1948      struct internal_aouthdr *ahdr;
1949 {
1950   if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
1951     fhdr->f_flags |= F_ALPHA_CALL_SHARED;
1952   else if ((abfd->flags & DYNAMIC) != 0)
1953     fhdr->f_flags |= F_ALPHA_SHARABLE;
1954   return true;
1955 }
1956 \f
1957 /* This is the ECOFF backend structure.  The backend field of the
1958    target vector points to this.  */
1959
1960 static const struct ecoff_backend_data alpha_ecoff_backend_data =
1961 {
1962   /* COFF backend structure.  */
1963   {
1964     (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1965     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1966     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1967     (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1968     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1969     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1970     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1971     alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
1972     alpha_ecoff_swap_scnhdr_out,
1973     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, true,
1974     alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
1975     alpha_ecoff_swap_scnhdr_in, NULL,
1976     alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1977     alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1978     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1979     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
1980   },
1981   /* Supported architecture.  */
1982   bfd_arch_alpha,
1983   /* Initial portion of armap string.  */
1984   "________64",
1985   /* The page boundary used to align sections in a demand-paged
1986      executable file.  E.g., 0x1000.  */
1987   0x2000,
1988   /* True if the .rdata section is part of the text segment, as on the
1989      Alpha.  False if .rdata is part of the data segment, as on the
1990      MIPS.  */
1991   true,
1992   /* Bitsize of constructor entries.  */
1993   64,
1994   /* Reloc to use for constructor entries.  */
1995   &alpha_howto_table[ALPHA_R_REFQUAD],
1996   {
1997     /* Symbol table magic number.  */
1998     magicSym2,
1999     /* Alignment of debugging information.  E.g., 4.  */
2000     8,
2001     /* Sizes of external symbolic information.  */
2002     sizeof (struct hdr_ext),
2003     sizeof (struct dnr_ext),
2004     sizeof (struct pdr_ext),
2005     sizeof (struct sym_ext),
2006     sizeof (struct opt_ext),
2007     sizeof (struct fdr_ext),
2008     sizeof (struct rfd_ext),
2009     sizeof (struct ext_ext),
2010     /* Functions to swap in external symbolic data.  */
2011     ecoff_swap_hdr_in,
2012     ecoff_swap_dnr_in,
2013     ecoff_swap_pdr_in,
2014     ecoff_swap_sym_in,
2015     ecoff_swap_opt_in,
2016     ecoff_swap_fdr_in,
2017     ecoff_swap_rfd_in,
2018     ecoff_swap_ext_in,
2019     _bfd_ecoff_swap_tir_in,
2020     _bfd_ecoff_swap_rndx_in,
2021     /* Functions to swap out external symbolic data.  */
2022     ecoff_swap_hdr_out,
2023     ecoff_swap_dnr_out,
2024     ecoff_swap_pdr_out,
2025     ecoff_swap_sym_out,
2026     ecoff_swap_opt_out,
2027     ecoff_swap_fdr_out,
2028     ecoff_swap_rfd_out,
2029     ecoff_swap_ext_out,
2030     _bfd_ecoff_swap_tir_out,
2031     _bfd_ecoff_swap_rndx_out,
2032     /* Function to read in symbolic data.  */
2033     _bfd_ecoff_slurp_symbolic_info
2034   },
2035   /* External reloc size.  */
2036   RELSZ,
2037   /* Reloc swapping functions.  */
2038   alpha_ecoff_swap_reloc_in,
2039   alpha_ecoff_swap_reloc_out,
2040   /* Backend reloc tweaking.  */
2041   alpha_adjust_reloc_in,
2042   alpha_adjust_reloc_out,
2043   /* Relocate section contents while linking.  */
2044   alpha_relocate_section,
2045   /* Do final adjustments to filehdr and aouthdr.  */
2046   alpha_adjust_headers
2047 };
2048
2049 /* Looking up a reloc type is Alpha specific.  */
2050 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2051
2052 /* So is getting relocated section contents.  */
2053 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2054   alpha_ecoff_get_relocated_section_contents
2055
2056 /* Relaxing sections is generic.  */
2057 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2058
2059 const bfd_target ecoffalpha_little_vec =
2060 {
2061   "ecoff-littlealpha",          /* name */
2062   bfd_target_ecoff_flavour,
2063   false,                        /* data byte order is little */
2064   false,                        /* header byte order is little */
2065
2066   (HAS_RELOC | EXEC_P |         /* object flags */
2067    HAS_LINENO | HAS_DEBUG |
2068    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2069
2070   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2071   0,                            /* leading underscore */
2072   ' ',                          /* ar_pad_char */
2073   15,                           /* ar_max_namelen */
2074   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2075      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2076      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2077   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2078      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2079      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2080
2081   {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2082      _bfd_ecoff_archive_p, _bfd_dummy_target},
2083   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2084      _bfd_generic_mkarchive, bfd_false},
2085   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2086      _bfd_write_archive_contents, bfd_false},
2087
2088      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2089      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2090      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2091      BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2092      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2093      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2094      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2095      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2096      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2097
2098   (PTR) &alpha_ecoff_backend_data
2099 };