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