bfd/coff-alpha.c

   1 /* BFD back-end for ALPHA Extended-Coff files.
   2    Copyright 1993, 1994, 1995, 1996 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 "aout/ar.h"
  32 #include "libcoff.h"
  33 #include "libecoff.h"
  34 \f
  35 /* Prototypes for static functions.  */
  36
  37 static const bfd_target *alpha_ecoff_object_p PARAMS ((bfd *));
  38 static boolean alpha_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
  39 static PTR alpha_ecoff_mkobject_hook PARAMS ((bfd *, PTR filehdr, PTR aouthdr));
  40 static void alpha_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
  41                                               struct internal_reloc *));
  42 static void alpha_ecoff_swap_reloc_out PARAMS ((bfd *,
  43                                                const struct internal_reloc *,
  44                                                PTR));
  45 static void alpha_adjust_reloc_in PARAMS ((bfd *,
  46                                            const struct internal_reloc *,
  47                                            arelent *));
  48 static void alpha_adjust_reloc_out PARAMS ((bfd *, const arelent *,
  49                                             struct internal_reloc *));
  50 static bfd_byte *alpha_ecoff_get_relocated_section_contents
  51   PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *,
  52            bfd_byte *data, boolean relocateable, asymbol **symbols));
  53 static bfd_vma alpha_convert_external_reloc
  54   PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *,
  55            struct ecoff_link_hash_entry *));
  56 static boolean alpha_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
  57                                                bfd *, asection *,
  58                                                bfd_byte *, PTR));
  59 static boolean alpha_adjust_headers
  60   PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *));
  61 static PTR alpha_ecoff_read_ar_hdr PARAMS ((bfd *));
  62 static bfd *alpha_ecoff_get_elt_at_filepos PARAMS ((bfd *, file_ptr));
  63 static bfd *alpha_ecoff_openr_next_archived_file PARAMS ((bfd *, bfd *));
  64 static bfd *alpha_ecoff_get_elt_at_index PARAMS ((bfd *, symindex));
  65 \f
  66 /* ECOFF has COFF sections, but the debugging information is stored in
  67    a completely different format.  ECOFF targets use some of the
  68    swapping routines from coffswap.h, and some of the generic COFF
  69    routines in coffgen.c, but, unlike the real COFF targets, do not
  70    use coffcode.h itself.
  71
  72    Get the generic COFF swapping routines, except for the reloc,
  73    symbol, and lineno ones.  Give them ecoff names.  Define some
  74    accessor macros for the large sizes used for Alpha ECOFF.  */
  75
  76 #define GET_FILEHDR_SYMPTR bfd_h_get_64
  77 #define PUT_FILEHDR_SYMPTR bfd_h_put_64
  78 #define GET_AOUTHDR_TSIZE bfd_h_get_64
  79 #define PUT_AOUTHDR_TSIZE bfd_h_put_64
  80 #define GET_AOUTHDR_DSIZE bfd_h_get_64
  81 #define PUT_AOUTHDR_DSIZE bfd_h_put_64
  82 #define GET_AOUTHDR_BSIZE bfd_h_get_64
  83 #define PUT_AOUTHDR_BSIZE bfd_h_put_64
  84 #define GET_AOUTHDR_ENTRY bfd_h_get_64
  85 #define PUT_AOUTHDR_ENTRY bfd_h_put_64
  86 #define GET_AOUTHDR_TEXT_START bfd_h_get_64
  87 #define PUT_AOUTHDR_TEXT_START bfd_h_put_64
  88 #define GET_AOUTHDR_DATA_START bfd_h_get_64
  89 #define PUT_AOUTHDR_DATA_START bfd_h_put_64
  90 #define GET_SCNHDR_PADDR bfd_h_get_64
  91 #define PUT_SCNHDR_PADDR bfd_h_put_64
  92 #define GET_SCNHDR_VADDR bfd_h_get_64
  93 #define PUT_SCNHDR_VADDR bfd_h_put_64
  94 #define GET_SCNHDR_SIZE bfd_h_get_64
  95 #define PUT_SCNHDR_SIZE bfd_h_put_64
  96 #define GET_SCNHDR_SCNPTR bfd_h_get_64
  97 #define PUT_SCNHDR_SCNPTR bfd_h_put_64
  98 #define GET_SCNHDR_RELPTR bfd_h_get_64
  99 #define PUT_SCNHDR_RELPTR bfd_h_put_64
 100 #define GET_SCNHDR_LNNOPTR bfd_h_get_64
 101 #define PUT_SCNHDR_LNNOPTR bfd_h_put_64
 102
 103 #define ALPHAECOFF
 104
 105 #define NO_COFF_RELOCS
 106 #define NO_COFF_SYMBOLS
 107 #define NO_COFF_LINENOS
 108 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
 109 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
 110 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
 111 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
 112 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
 113 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
 114 #include "coffswap.h"
 115
 116 /* Get the ECOFF swapping routines.  */
 117 #define ECOFF_64
 118 #include "ecoffswap.h"
 119 \f
 120 /* How to process the various reloc types.  */
 121
 122 static bfd_reloc_status_type
 123 reloc_nil PARAMS ((bfd *, arelent *, asymbol *, PTR,
 124                    asection *, bfd *, char **));
 125
 126 static bfd_reloc_status_type
 127 reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
 128      bfd *abfd;
 129      arelent *reloc;
 130      asymbol *sym;
 131      PTR data;
 132      asection *sec;
 133      bfd *output_bfd;
 134      char **error_message;
 135 {
 136   return bfd_reloc_ok;
 137 }
 138
 139 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 140    from smaller values.  Start with zero, widen, *then* decrement.  */
 141 #define MINUS_ONE       (((bfd_vma)0) - 1)
 142
 143 static reloc_howto_type alpha_howto_table[] =
 144 {
 145   /* Reloc type 0 is ignored by itself.  However, it appears after a
 146      GPDISP reloc to identify the location where the low order 16 bits
 147      of the gp register are loaded.  */
 148   HOWTO (ALPHA_R_IGNORE,        /* type */
 149          0,                     /* rightshift */
 150          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 151          8,                     /* bitsize */
 152          true,                  /* pc_relative */
 153          0,                     /* bitpos */
 154          complain_overflow_dont, /* complain_on_overflow */
 155          reloc_nil,             /* special_function */
 156          "IGNORE",              /* name */
 157          true,                  /* partial_inplace */
 158          0,                     /* src_mask */
 159          0,                     /* dst_mask */
 160          true),                 /* pcrel_offset */
 161
 162   /* A 32 bit reference to a symbol.  */
 163   HOWTO (ALPHA_R_REFLONG,       /* type */
 164          0,                     /* rightshift */
 165          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 166          32,                    /* bitsize */
 167          false,                 /* pc_relative */
 168          0,                     /* bitpos */
 169          complain_overflow_bitfield, /* complain_on_overflow */
 170          0,                     /* special_function */
 171          "REFLONG",             /* name */
 172          true,                  /* partial_inplace */
 173          0xffffffff,            /* src_mask */
 174          0xffffffff,            /* dst_mask */
 175          false),                /* pcrel_offset */
 176
 177   /* A 64 bit reference to a symbol.  */
 178   HOWTO (ALPHA_R_REFQUAD,       /* type */
 179          0,                     /* rightshift */
 180          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 181          64,                    /* bitsize */
 182          false,                 /* pc_relative */
 183          0,                     /* bitpos */
 184          complain_overflow_bitfield, /* complain_on_overflow */
 185          0,                     /* special_function */
 186          "REFQUAD",             /* name */
 187          true,                  /* partial_inplace */
 188          MINUS_ONE,             /* src_mask */
 189          MINUS_ONE,             /* dst_mask */
 190          false),                /* pcrel_offset */
 191
 192   /* A 32 bit GP relative offset.  This is just like REFLONG except
 193      that when the value is used the value of the gp register will be
 194      added in.  */
 195   HOWTO (ALPHA_R_GPREL32,       /* type */
 196          0,                     /* rightshift */
 197          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 198          32,                    /* bitsize */
 199          false,                 /* pc_relative */
 200          0,                     /* bitpos */
 201          complain_overflow_bitfield, /* complain_on_overflow */
 202          0,                     /* special_function */
 203          "GPREL32",             /* name */
 204          true,                  /* partial_inplace */
 205          0xffffffff,            /* src_mask */
 206          0xffffffff,            /* dst_mask */
 207          false),                /* pcrel_offset */
 208
 209   /* Used for an instruction that refers to memory off the GP
 210      register.  The offset is 16 bits of the 32 bit instruction.  This
 211      reloc always seems to be against the .lita section.  */
 212   HOWTO (ALPHA_R_LITERAL,       /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          16,                    /* bitsize */
 216          false,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_signed, /* complain_on_overflow */
 219          0,                     /* special_function */
 220          "LITERAL",             /* name */
 221          true,                  /* partial_inplace */
 222          0xffff,                /* src_mask */
 223          0xffff,                /* dst_mask */
 224          false),                /* pcrel_offset */
 225
 226   /* This reloc only appears immediately following a LITERAL reloc.
 227      It identifies a use of the literal.  It seems that the linker can
 228      use this to eliminate a portion of the .lita section.  The symbol
 229      index is special: 1 means the literal address is in the base
 230      register of a memory format instruction; 2 means the literal
 231      address is in the byte offset register of a byte-manipulation
 232      instruction; 3 means the literal address is in the target
 233      register of a jsr instruction.  This does not actually do any
 234      relocation.  */
 235   HOWTO (ALPHA_R_LITUSE,        /* type */
 236          0,                     /* rightshift */
 237          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 238          32,                    /* bitsize */
 239          false,                 /* pc_relative */
 240          0,                     /* bitpos */
 241          complain_overflow_dont, /* complain_on_overflow */
 242          reloc_nil,             /* special_function */
 243          "LITUSE",              /* name */
 244          false,                 /* partial_inplace */
 245          0,                     /* src_mask */
 246          0,                     /* dst_mask */
 247          false),                /* pcrel_offset */
 248
 249   /* Load the gp register.  This is always used for a ldah instruction
 250      which loads the upper 16 bits of the gp register.  The next reloc
 251      will be an IGNORE reloc which identifies the location of the lda
 252      instruction which loads the lower 16 bits.  The symbol index of
 253      the GPDISP instruction appears to actually be the number of bytes
 254      between the ldah and lda instructions.  This gives two different
 255      ways to determine where the lda instruction is; I don't know why
 256      both are used.  The value to use for the relocation is the
 257      difference between the GP value and the current location; the
 258      load will always be done against a register holding the current
 259      address.  */
 260   HOWTO (ALPHA_R_GPDISP,        /* type */
 261          16,                    /* rightshift */
 262          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 263          16,                    /* bitsize */
 264          true,                  /* pc_relative */
 265          0,                     /* bitpos */
 266          complain_overflow_dont, /* complain_on_overflow */
 267          reloc_nil,             /* special_function */
 268          "GPDISP",              /* name */
 269          true,                  /* partial_inplace */
 270          0xffff,                /* src_mask */
 271          0xffff,                /* dst_mask */
 272          true),                 /* pcrel_offset */
 273
 274   /* A 21 bit branch.  The native assembler generates these for
 275      branches within the text segment, and also fills in the PC
 276      relative offset in the instruction.  */
 277   HOWTO (ALPHA_R_BRADDR,        /* type */
 278          2,                     /* rightshift */
 279          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          21,                    /* bitsize */
 281          true,                  /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_signed, /* complain_on_overflow */
 284          0,                     /* special_function */
 285          "BRADDR",              /* name */
 286          true,                  /* partial_inplace */
 287          0x1fffff,              /* src_mask */
 288          0x1fffff,              /* dst_mask */
 289          false),                /* pcrel_offset */
 290
 291   /* A hint for a jump to a register.  */
 292   HOWTO (ALPHA_R_HINT,          /* type */
 293          2,                     /* rightshift */
 294          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          14,                    /* bitsize */
 296          true,                  /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_dont, /* complain_on_overflow */
 299          0,                     /* special_function */
 300          "HINT",                /* name */
 301          true,                  /* partial_inplace */
 302          0x3fff,                /* src_mask */
 303          0x3fff,                /* dst_mask */
 304          false),                /* pcrel_offset */
 305
 306   /* 16 bit PC relative offset.  */
 307   HOWTO (ALPHA_R_SREL16,        /* type */
 308          0,                     /* rightshift */
 309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          16,                    /* bitsize */
 311          true,                  /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_signed, /* complain_on_overflow */
 314          0,                     /* special_function */
 315          "SREL16",              /* name */
 316          true,                  /* partial_inplace */
 317          0xffff,                /* src_mask */
 318          0xffff,                /* dst_mask */
 319          false),                /* pcrel_offset */
 320
 321   /* 32 bit PC relative offset.  */
 322   HOWTO (ALPHA_R_SREL32,        /* type */
 323          0,                     /* rightshift */
 324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          32,                    /* bitsize */
 326          true,                  /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_signed, /* complain_on_overflow */
 329          0,                     /* special_function */
 330          "SREL32",              /* name */
 331          true,                  /* partial_inplace */
 332          0xffffffff,            /* src_mask */
 333          0xffffffff,            /* dst_mask */
 334          false),                /* pcrel_offset */
 335
 336   /* A 64 bit PC relative offset.  */
 337   HOWTO (ALPHA_R_SREL64,        /* type */
 338          0,                     /* rightshift */
 339          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          64,                    /* bitsize */
 341          true,                  /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_signed, /* complain_on_overflow */
 344          0,                     /* special_function */
 345          "SREL64",              /* name */
 346          true,                  /* partial_inplace */
 347          MINUS_ONE,             /* src_mask */
 348          MINUS_ONE,             /* dst_mask */
 349          false),                /* pcrel_offset */
 350
 351   /* Push a value on the reloc evaluation stack.  */
 352   HOWTO (ALPHA_R_OP_PUSH,       /* type */
 353          0,                     /* rightshift */
 354          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          0,                     /* bitsize */
 356          false,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_dont, /* complain_on_overflow */
 359          0,                     /* special_function */
 360          "OP_PUSH",             /* name */
 361          false,                 /* partial_inplace */
 362          0,                     /* src_mask */
 363          0,                     /* dst_mask */
 364          false),                /* pcrel_offset */
 365
 366   /* Store the value from the stack at the given address.  Store it in
 367      a bitfield of size r_size starting at bit position r_offset.  */
 368   HOWTO (ALPHA_R_OP_STORE,      /* type */
 369          0,                     /* rightshift */
 370          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 371          64,                    /* bitsize */
 372          false,                 /* pc_relative */
 373          0,                     /* bitpos */
 374          complain_overflow_dont, /* complain_on_overflow */
 375          0,                     /* special_function */
 376          "OP_STORE",            /* name */
 377          false,                 /* partial_inplace */
 378          0,                     /* src_mask */
 379          MINUS_ONE,             /* dst_mask */
 380          false),                /* pcrel_offset */
 381
 382   /* Subtract the reloc address from the value on the top of the
 383      relocation stack.  */
 384   HOWTO (ALPHA_R_OP_PSUB,       /* type */
 385          0,                     /* rightshift */
 386          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          0,                     /* bitsize */
 388          false,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_dont, /* complain_on_overflow */
 391          0,                     /* special_function */
 392          "OP_PSUB",             /* name */
 393          false,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0,                     /* dst_mask */
 396          false),                /* pcrel_offset */
 397
 398   /* Shift the value on the top of the relocation stack right by the
 399      given value.  */
 400   HOWTO (ALPHA_R_OP_PRSHIFT,    /* type */
 401          0,                     /* rightshift */
 402          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 403          0,                     /* bitsize */
 404          false,                 /* pc_relative */
 405          0,                     /* bitpos */
 406          complain_overflow_dont, /* complain_on_overflow */
 407          0,                     /* special_function */
 408          "OP_PRSHIFT",          /* name */
 409          false,                 /* partial_inplace */
 410          0,                     /* src_mask */
 411          0,                     /* dst_mask */
 412          false),                /* pcrel_offset */
 413
 414   /* Adjust the GP value for a new range in the object file.  */
 415   HOWTO (ALPHA_R_GPVALUE,       /* type */
 416          0,                     /* rightshift */
 417          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          0,                     /* bitsize */
 419          false,                 /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_dont, /* complain_on_overflow */
 422          0,                     /* special_function */
 423          "GPVALUE",             /* name */
 424          false,                 /* partial_inplace */
 425          0,                     /* src_mask */
 426          0,                     /* dst_mask */
 427          false)                 /* pcrel_offset */
 428 };
 429 \f
 430 /* Recognize an Alpha ECOFF file.  */
 431
 432 static const bfd_target *
 433 alpha_ecoff_object_p (abfd)
 434      bfd *abfd;
 435 {
 436   static const bfd_target *ret;
 437
 438   ret = coff_object_p (abfd);
 439
 440   if (ret != NULL)
 441     {
 442       asection *sec;
 443
 444       /* Alpha ECOFF has a .pdata section.  The lnnoptr field of the
 445          .pdata section is the number of entries it contains.  Each
 446          entry takes up 8 bytes.  The number of entries is required
 447          since the section is aligned to a 16 byte boundary.  When we
 448          link .pdata sections together, we do not want to include the
 449          alignment bytes.  We handle this on input by faking the size
 450          of the .pdata section to remove the unwanted alignment bytes.
 451          On output we will set the lnnoptr field and force the
 452          alignment.  */
 453       sec = bfd_get_section_by_name (abfd, _PDATA);
 454       if (sec != (asection *) NULL)
 455         {
 456           bfd_size_type size;
 457
 458           size = sec->line_filepos * 8;
 459           BFD_ASSERT (size == bfd_section_size (abfd, sec)
 460                       || size + 8 == bfd_section_size (abfd, sec));
 461           if (! bfd_set_section_size (abfd, sec, size))
 462             return NULL;
 463         }
 464     }
 465
 466   return ret;
 467 }
 468
 469 /* See whether the magic number matches.  */
 470
 471 static boolean
 472 alpha_ecoff_bad_format_hook (abfd, filehdr)
 473      bfd *abfd;
 474      PTR filehdr;
 475 {
 476   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 477
 478   if (ALPHA_ECOFF_BADMAG (*internal_f))
 479     return false;
 480
 481   return true;
 482 }
 483
 484 /* This is a hook called by coff_real_object_p to create any backend
 485    specific information.  */
 486
 487 static PTR
 488 alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
 489      bfd *abfd;
 490      PTR filehdr;
 491      PTR aouthdr;
 492 {
 493   PTR ecoff;
 494
 495   ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
 496
 497   if (ecoff != NULL)
 498     {
 499       struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 500
 501       /* Set additional BFD flags according to the object type from the
 502          machine specific file header flags.  */
 503       switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
 504         {
 505         case F_ALPHA_SHARABLE:
 506           abfd->flags |= DYNAMIC;
 507           break;
 508         case F_ALPHA_CALL_SHARED:
 509           /* Always executable if using shared libraries as the run time
 510              loader might resolve undefined references.  */
 511           abfd->flags |= (DYNAMIC | EXEC_P);
 512           break;
 513         }
 514     }
 515   return ecoff;
 516 }
 517 \f
 518 /* Reloc handling.  */
 519
 520 /* Swap a reloc in.  */
 521
 522 static void
 523 alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
 524      bfd *abfd;
 525      PTR ext_ptr;
 526      struct internal_reloc *intern;
 527 {
 528   const RELOC *ext = (RELOC *) ext_ptr;
 529
 530   intern->r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext->r_vaddr);
 531   intern->r_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_symndx);
 532
 533   BFD_ASSERT (bfd_header_little_endian (abfd));
 534
 535   intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
 536                     >> RELOC_BITS0_TYPE_SH_LITTLE);
 537   intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
 538   intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
 539                       >> RELOC_BITS1_OFFSET_SH_LITTLE);
 540   /* Ignored the reserved bits.  */
 541   intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
 542                     >> RELOC_BITS3_SIZE_SH_LITTLE);
 543
 544   if (intern->r_type == ALPHA_R_LITUSE
 545       || intern->r_type == ALPHA_R_GPDISP)
 546     {
 547       /* Handle the LITUSE and GPDISP relocs specially.  Its symndx
 548          value is not actually a symbol index, but is instead a
 549          special code.  We put the code in the r_size field, and
 550          clobber the symndx.  */
 551       if (intern->r_size != 0)
 552         abort ();
 553       intern->r_size = intern->r_symndx;
 554       intern->r_symndx = RELOC_SECTION_NONE;
 555     }
 556   else if (intern->r_type == ALPHA_R_IGNORE)
 557     {
 558       /* The IGNORE reloc generally follows a GPDISP reloc, and is
 559          against the .lita section.  The section is irrelevant.  */
 560       if (! intern->r_extern &&
 561           intern->r_symndx == RELOC_SECTION_ABS)
 562         abort ();
 563       if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
 564         intern->r_symndx = RELOC_SECTION_ABS;
 565     }
 566 }
 567
 568 /* Swap a reloc out.  */
 569
 570 static void
 571 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
 572      bfd *abfd;
 573      const struct internal_reloc *intern;
 574      PTR dst;
 575 {
 576   RELOC *ext = (RELOC *) dst;
 577   long symndx;
 578   unsigned char size;
 579
 580   /* Undo the hackery done in swap_reloc_in.  */
 581   if (intern->r_type == ALPHA_R_LITUSE
 582       || intern->r_type == ALPHA_R_GPDISP)
 583     {
 584       symndx = intern->r_size;
 585       size = 0;
 586     }
 587   else if (intern->r_type == ALPHA_R_IGNORE
 588            && ! intern->r_extern
 589            && intern->r_symndx == RELOC_SECTION_ABS)
 590     {
 591       symndx = RELOC_SECTION_LITA;
 592       size = intern->r_size;
 593     }
 594   else
 595     {
 596       symndx = intern->r_symndx;
 597       size = intern->r_size;
 598     }
 599
 600   BFD_ASSERT (intern->r_extern
 601               || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
 602
 603   bfd_h_put_64 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
 604   bfd_h_put_32 (abfd, symndx, (bfd_byte *) ext->r_symndx);
 605
 606   BFD_ASSERT (bfd_header_little_endian (abfd));
 607
 608   ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
 609                     & RELOC_BITS0_TYPE_LITTLE);
 610   ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
 611                     | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
 612                        & RELOC_BITS1_OFFSET_LITTLE));
 613   ext->r_bits[2] = 0;
 614   ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
 615                     & RELOC_BITS3_SIZE_LITTLE);
 616 }
 617
 618 /* Finish canonicalizing a reloc.  Part of this is generic to all
 619    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 620    this backend routine.  It must fill in the howto field.  */
 621
 622 static void
 623 alpha_adjust_reloc_in (abfd, intern, rptr)
 624      bfd *abfd;
 625      const struct internal_reloc *intern;
 626      arelent *rptr;
 627 {
 628   if (intern->r_type > ALPHA_R_GPVALUE)
 629     abort ();
 630
 631   switch (intern->r_type)
 632     {
 633     case ALPHA_R_BRADDR:
 634     case ALPHA_R_SREL16:
 635     case ALPHA_R_SREL32:
 636     case ALPHA_R_SREL64:
 637       /* The PC relative relocs do not seem to use the section VMA as
 638          a negative addend.  */
 639       rptr->addend = 0;
 640       break;
 641
 642     case ALPHA_R_GPREL32:
 643     case ALPHA_R_LITERAL:
 644       /* Copy the gp value for this object file into the addend, to
 645          ensure that we are not confused by the linker.  */
 646       if (! intern->r_extern)
 647         rptr->addend += ecoff_data (abfd)->gp;
 648       break;
 649
 650     case ALPHA_R_LITUSE:
 651     case ALPHA_R_GPDISP:
 652       /* The LITUSE and GPDISP relocs do not use a symbol, or an
 653          addend, but they do use a special code.  Put this code in the
 654          addend field.  */
 655       rptr->addend = intern->r_size;
 656       break;
 657
 658     case ALPHA_R_OP_STORE:
 659       /* The STORE reloc needs the size and offset fields.  We store
 660          them in the addend.  */
 661       BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
 662       rptr->addend = (intern->r_offset << 8) + intern->r_size;
 663       break;
 664
 665     case ALPHA_R_OP_PUSH:
 666     case ALPHA_R_OP_PSUB:
 667     case ALPHA_R_OP_PRSHIFT:
 668       /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
 669          address.  I believe that the address supplied is really an
 670          addend.  */
 671       rptr->addend = intern->r_vaddr;
 672       break;
 673
 674     case ALPHA_R_GPVALUE:
 675       /* Set the addend field to the new GP value.  */
 676       rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
 677       break;
 678
 679     case ALPHA_R_IGNORE:
 680       /* If the type is ALPHA_R_IGNORE, make sure this is a reference
 681          to the absolute section so that the reloc is ignored.  For
 682          some reason the address of this reloc type is not adjusted by
 683          the section vma.  We record the gp value for this object file
 684          here, for convenience when doing the GPDISP relocation.  */
 685       rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 686       rptr->address = intern->r_vaddr;
 687       rptr->addend = ecoff_data (abfd)->gp;
 688       break;
 689
 690     default:
 691       break;
 692     }
 693
 694   rptr->howto = &alpha_howto_table[intern->r_type];
 695 }
 696
 697 /* When writing out a reloc we need to pull some values back out of
 698    the addend field into the reloc.  This is roughly the reverse of
 699    alpha_adjust_reloc_in, except that there are several changes we do
 700    not need to undo.  */
 701
 702 static void
 703 alpha_adjust_reloc_out (abfd, rel, intern)
 704      bfd *abfd;
 705      const arelent *rel;
 706      struct internal_reloc *intern;
 707 {
 708   switch (intern->r_type)
 709     {
 710     case ALPHA_R_LITUSE:
 711     case ALPHA_R_GPDISP:
 712       intern->r_size = rel->addend;
 713       break;
 714
 715     case ALPHA_R_OP_STORE:
 716       intern->r_size = rel->addend & 0xff;
 717       intern->r_offset = (rel->addend >> 8) & 0xff;
 718       break;
 719
 720     case ALPHA_R_OP_PUSH:
 721     case ALPHA_R_OP_PSUB:
 722     case ALPHA_R_OP_PRSHIFT:
 723       intern->r_vaddr = rel->addend;
 724       break;
 725
 726     case ALPHA_R_IGNORE:
 727       intern->r_vaddr = rel->address;
 728       break;
 729
 730     default:
 731       break;
 732     }
 733 }
 734
 735 /* The size of the stack for the relocation evaluator.  */
 736 #define RELOC_STACKSIZE (10)
 737
 738 /* Alpha ECOFF relocs have a built in expression evaluator as well as
 739    other interdependencies.  Rather than use a bunch of special
 740    functions and global variables, we use a single routine to do all
 741    the relocation for a section.  I haven't yet worked out how the
 742    assembler is going to handle this.  */
 743
 744 static bfd_byte *
 745 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
 746                                             data, relocateable, symbols)
 747      bfd *abfd;
 748      struct bfd_link_info *link_info;
 749      struct bfd_link_order *link_order;
 750      bfd_byte *data;
 751      boolean relocateable;
 752      asymbol **symbols;
 753 {
 754   bfd *input_bfd = link_order->u.indirect.section->owner;
 755   asection *input_section = link_order->u.indirect.section;
 756   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
 757   arelent **reloc_vector = NULL;
 758   long reloc_count;
 759   bfd *output_bfd = relocateable ? abfd : (bfd *) NULL;
 760   bfd_vma gp;
 761   boolean gp_undefined;
 762   bfd_vma gp;
 763   bfd_vma stack[RELOC_STACKSIZE];
 764   int tos = 0;
 765
 766   if (reloc_size < 0)
 767     goto error_return;
 768   reloc_vector = (arelent **) bfd_malloc (reloc_size);
 769   if (reloc_vector == NULL && reloc_size != 0)
 770     goto error_return;
 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   gp = _bfd_get_gp_value (abfd);
 790   if (gp == 0)
 791     {
 792       if (relocateable != false)
 793         {
 794           asection *sec;
 795           bfd_vma lo;
 796
 797           /* Make up a value.  */
 798           lo = (bfd_vma) -1;
 799           for (sec = abfd->sections; sec != NULL; sec = sec->next)
 800             {
 801               if (sec->vma < lo
 802                   && (strcmp (sec->name, ".sbss") == 0
 803                       || strcmp (sec->name, ".sdata") == 0
 804                       || strcmp (sec->name, ".lit4") == 0
 805                       || strcmp (sec->name, ".lit8") == 0
 806                       || strcmp (sec->name, ".lita") == 0))
 807                 lo = sec->vma;
 808             }
 809           gp = lo + 0x8000;
 810           _bfd_set_gp_value (abfd, gp);
 811         }
 812       else
 813         {
 814           struct bfd_link_hash_entry *h;
 815
 816           h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false,
 817                                     true);
 818           if (h == (struct bfd_link_hash_entry *) NULL
 819               || h->type != bfd_link_hash_defined)
 820             gp_undefined = true;
 821           else
 822             {
 823               gp = (h->u.def.value
 824                     + h->u.def.section->output_section->vma
 825                     + h->u.def.section->output_offset);
 826               _bfd_set_gp_value (abfd, gp);
 827             }
 828         }
 829     }
 830
 831   for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
 832     {
 833       arelent *rel;
 834       bfd_reloc_status_type r;
 835       char *err;
 836
 837       rel = *reloc_vector;
 838       r = bfd_reloc_ok;
 839       switch (rel->howto->type)
 840         {
 841         case ALPHA_R_IGNORE:
 842           rel->address += input_section->output_offset;
 843           break;
 844
 845         case ALPHA_R_REFLONG:
 846         case ALPHA_R_REFQUAD:
 847         case ALPHA_R_BRADDR:
 848         case ALPHA_R_HINT:
 849         case ALPHA_R_SREL16:
 850         case ALPHA_R_SREL32:
 851         case ALPHA_R_SREL64:
 852           if (relocateable
 853               && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
 854             {
 855               rel->address += input_section->output_offset;
 856               break;
 857             }
 858           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 859                                       output_bfd, &err);
 860           break;
 861
 862         case ALPHA_R_GPREL32:
 863           /* This relocation is used in a switch table.  It is a 32
 864              bit offset from the current GP value.  We must adjust it
 865              by the different between the original GP value and the
 866              current GP value.  The original GP value is stored in the
 867              addend.  We adjust the addend and let
 868              bfd_perform_relocation finish the job.  */
 869           rel->addend -= gp;
 870           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 871                                       output_bfd, &err);
 872           if (r == bfd_reloc_ok && gp_undefined)
 873             {
 874               r = bfd_reloc_dangerous;
 875               err = (char *) "GP relative relocation used when GP not defined";
 876             }
 877           break;
 878
 879         case ALPHA_R_LITERAL:
 880           /* This is a reference to a literal value, generally
 881              (always?) in the .lita section.  This is a 16 bit GP
 882              relative relocation.  Sometimes the subsequent reloc is a
 883              LITUSE reloc, which indicates how this reloc is used.
 884              This sometimes permits rewriting the two instructions
 885              referred to by the LITERAL and the LITUSE into different
 886              instructions which do not refer to .lita.  This can save
 887              a memory reference, and permits removing a value from
 888              .lita thus saving GP relative space.
 889
 890              We do not these optimizations.  To do them we would need
 891              to arrange to link the .lita section first, so that by
 892              the time we got here we would know the final values to
 893              use.  This would not be particularly difficult, but it is
 894              not currently implemented.  */
 895
 896           {
 897             unsigned long insn;
 898
 899             /* I believe that the LITERAL reloc will only apply to a
 900                ldq or ldl instruction, so check my assumption.  */
 901             insn = bfd_get_32 (input_bfd, data + rel->address);
 902             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
 903                         || ((insn >> 26) & 0x3f) == 0x28);
 904
 905             rel->addend -= gp;
 906             r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 907                                         output_bfd, &err);
 908             if (r == bfd_reloc_ok && gp_undefined)
 909               {
 910                 r = bfd_reloc_dangerous;
 911                 err =
 912                   (char *) "GP relative relocation used when GP not defined";
 913               }
 914           }
 915           break;
 916
 917         case ALPHA_R_LITUSE:
 918           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
 919              does not cause anything to happen, itself.  */
 920           rel->address += input_section->output_offset;
 921           break;
 922
 923         case ALPHA_R_GPDISP:
 924           /* This marks the ldah of an ldah/lda pair which loads the
 925              gp register with the difference of the gp value and the
 926              current location.  The second of the pair is r_size bytes
 927              ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
 928              but that no longer happens in OSF/1 3.2.  */
 929           {
 930             unsigned long insn1, insn2;
 931             bfd_vma addend;
 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 -= (ecoff_data (input_bfd)->gp
 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           else if (strcmp (name, ".rconst") == 0)
1313             r_symndx = RELOC_SECTION_RCONST;
1314           break;
1315         case 's':
1316           if (strcmp (name, ".sdata") == 0)
1317             r_symndx = RELOC_SECTION_SDATA;
1318           else if (strcmp (name, ".sbss") == 0)
1319             r_symndx = RELOC_SECTION_SBSS;
1320           break;
1321         case 't':
1322           if (strcmp (name, ".text") == 0)
1323             r_symndx = RELOC_SECTION_TEXT;
1324           break;
1325         case 'x':
1326           if (strcmp (name, ".xdata") == 0)
1327             r_symndx = RELOC_SECTION_XDATA;
1328           break;
1329         }
1330
1331       if (r_symndx == -1)
1332         abort ();
1333
1334       /* Add the section VMA and the symbol value.  */
1335       relocation = (h->root.u.def.value
1336                     + hsec->output_section->vma
1337                     + hsec->output_offset);
1338     }
1339   else
1340     {
1341       /* Change the symndx value to the right one for
1342          the output BFD.  */
1343       r_symndx = h->indx;
1344       if (r_symndx == -1)
1345         {
1346           /* Caller must give an error.  */
1347           r_symndx = 0;
1348         }
1349       relocation = 0;
1350     }
1351
1352   /* Write out the new r_symndx value.  */
1353   bfd_h_put_32 (input_bfd, (bfd_vma) r_symndx,
1354                 (bfd_byte *) ext_rel->r_symndx);
1355
1356   return relocation;
1357 }
1358
1359 /* Relocate a section while linking an Alpha ECOFF file.  This is
1360    quite similar to get_relocated_section_contents.  Perhaps they
1361    could be combined somehow.  */
1362
1363 static boolean
1364 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1365                         contents, external_relocs)
1366      bfd *output_bfd;
1367      struct bfd_link_info *info;
1368      bfd *input_bfd;
1369      asection *input_section;
1370      bfd_byte *contents;
1371      PTR external_relocs;
1372 {
1373   asection **symndx_to_section, *lita_sec;
1374   struct ecoff_link_hash_entry **sym_hashes;
1375   bfd_vma gp;
1376   boolean gp_undefined;
1377   bfd_vma stack[RELOC_STACKSIZE];
1378   int tos = 0;
1379   struct external_reloc *ext_rel;
1380   struct external_reloc *ext_rel_end;
1381
1382   /* We keep a table mapping the symndx found in an internal reloc to
1383      the appropriate section.  This is faster than looking up the
1384      section by name each time.  */
1385   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1386   if (symndx_to_section == (asection **) NULL)
1387     {
1388       symndx_to_section = ((asection **)
1389                            bfd_alloc (input_bfd,
1390                                       (NUM_RELOC_SECTIONS
1391                                        * sizeof (asection *))));
1392       if (!symndx_to_section)
1393         return false;
1394
1395       symndx_to_section[RELOC_SECTION_NONE] = NULL;
1396       symndx_to_section[RELOC_SECTION_TEXT] =
1397         bfd_get_section_by_name (input_bfd, ".text");
1398       symndx_to_section[RELOC_SECTION_RDATA] =
1399         bfd_get_section_by_name (input_bfd, ".rdata");
1400       symndx_to_section[RELOC_SECTION_DATA] =
1401         bfd_get_section_by_name (input_bfd, ".data");
1402       symndx_to_section[RELOC_SECTION_SDATA] =
1403         bfd_get_section_by_name (input_bfd, ".sdata");
1404       symndx_to_section[RELOC_SECTION_SBSS] =
1405         bfd_get_section_by_name (input_bfd, ".sbss");
1406       symndx_to_section[RELOC_SECTION_BSS] =
1407         bfd_get_section_by_name (input_bfd, ".bss");
1408       symndx_to_section[RELOC_SECTION_INIT] =
1409         bfd_get_section_by_name (input_bfd, ".init");
1410       symndx_to_section[RELOC_SECTION_LIT8] =
1411         bfd_get_section_by_name (input_bfd, ".lit8");
1412       symndx_to_section[RELOC_SECTION_LIT4] =
1413         bfd_get_section_by_name (input_bfd, ".lit4");
1414       symndx_to_section[RELOC_SECTION_XDATA] =
1415         bfd_get_section_by_name (input_bfd, ".xdata");
1416       symndx_to_section[RELOC_SECTION_PDATA] =
1417         bfd_get_section_by_name (input_bfd, ".pdata");
1418       symndx_to_section[RELOC_SECTION_FINI] =
1419         bfd_get_section_by_name (input_bfd, ".fini");
1420       symndx_to_section[RELOC_SECTION_LITA] =
1421         bfd_get_section_by_name (input_bfd, ".lita");
1422       symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1423       symndx_to_section[RELOC_SECTION_RCONST] =
1424         bfd_get_section_by_name (input_bfd, ".rconst");
1425
1426       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1427     }
1428
1429   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1430
1431   /* On the Alpha, the .lita section must be addressable by the global
1432      pointer.  To support large programs, we need to allow multiple
1433      global pointers.  This works as long as each input .lita section
1434      is <64KB big.  This implies that when producing relocatable
1435      output, the .lita section is limited to 64KB. . */
1436
1437   lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1438   gp = _bfd_get_gp_value (output_bfd);
1439   if (! info->relocateable && lita_sec != NULL)
1440     {
1441       struct ecoff_section_tdata *lita_sec_data;
1442
1443       /* Make sure we have a section data structure to which we can
1444          hang on to the gp value we pick for the section.  */
1445       lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1446       if (lita_sec_data == NULL)
1447         {
1448           lita_sec_data = ((struct ecoff_section_tdata *)
1449                            bfd_zalloc (input_bfd,
1450                                        sizeof (struct ecoff_section_tdata)));
1451           ecoff_section_data (input_bfd, lita_sec) = lita_sec_data;
1452         }
1453
1454       if (lita_sec_data->gp != 0)
1455         {
1456           /* If we already assigned a gp to this section, we better
1457              stick with that value.  */
1458           gp = lita_sec_data->gp;
1459         }
1460       else
1461         {
1462           bfd_vma lita_vma;
1463           bfd_size_type lita_size;
1464
1465           lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1466           lita_size = lita_sec->_cooked_size;
1467           if (lita_size == 0)
1468             lita_size = lita_sec->_raw_size;
1469
1470           if (gp == 0
1471               || lita_vma <  gp - 0x8000
1472               || lita_vma + lita_size >= gp + 0x8000)
1473             {
1474               /* Either gp hasn't been set at all or the current gp
1475                  cannot address this .lita section.  In both cases we
1476                  reset the gp to point into the "middle" of the
1477                  current input .lita section.  For now, we issue a
1478                  warning when redefining the gp value (probably should
1479                  be made optional). */
1480               if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1481                 {
1482                   (*_bfd_error_handler)
1483                     ("%s: warning: using multiple gp values",
1484                      bfd_get_filename (output_bfd));
1485                   ecoff_data (output_bfd)->issued_multiple_gp_warning = true;
1486                 }
1487               if (lita_vma < gp - 0x8000)
1488                 gp = lita_vma + lita_size - 0x8000;
1489               else
1490                 gp = lita_vma + 0x8000;
1491
1492             }
1493
1494           lita_sec_data->gp = gp;
1495         }
1496
1497       _bfd_set_gp_value (output_bfd, gp);
1498     }
1499
1500   gp_undefined = (gp == 0);
1501
1502   BFD_ASSERT (bfd_header_little_endian (output_bfd));
1503   BFD_ASSERT (bfd_header_little_endian (input_bfd));
1504
1505   ext_rel = (struct external_reloc *) external_relocs;
1506   ext_rel_end = ext_rel + input_section->reloc_count;
1507   for (; ext_rel < ext_rel_end; ext_rel++)
1508     {
1509       bfd_vma r_vaddr;
1510       unsigned long r_symndx;
1511       int r_type;
1512       int r_extern;
1513       int r_offset;
1514       int r_size;
1515       boolean relocatep;
1516       boolean adjust_addrp;
1517       boolean gp_usedp;
1518       bfd_vma addend;
1519
1520       r_vaddr = bfd_h_get_64 (input_bfd, (bfd_byte *) ext_rel->r_vaddr);
1521       r_symndx = bfd_h_get_32 (input_bfd, (bfd_byte *) ext_rel->r_symndx);
1522
1523       r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1524                 >> RELOC_BITS0_TYPE_SH_LITTLE);
1525       r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1526       r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1527                   >> RELOC_BITS1_OFFSET_SH_LITTLE);
1528       /* Ignored the reserved bits.  */
1529       r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1530                 >> RELOC_BITS3_SIZE_SH_LITTLE);
1531
1532       relocatep = false;
1533       adjust_addrp = true;
1534       gp_usedp = false;
1535       addend = 0;
1536
1537       switch (r_type)
1538         {
1539         default:
1540           abort ();
1541
1542         case ALPHA_R_IGNORE:
1543           /* This reloc appears after a GPDISP reloc.  On earlier
1544              versions of OSF/1, It marked the position of the second
1545              instruction to be altered by the GPDISP reloc, but it is
1546              not otherwise used for anything.  For some reason, the
1547              address of the relocation does not appear to include the
1548              section VMA, unlike the other relocation types.  */
1549           if (info->relocateable)
1550             bfd_h_put_64 (input_bfd,
1551                           input_section->output_offset + r_vaddr,
1552                           (bfd_byte *) ext_rel->r_vaddr);
1553           adjust_addrp = false;
1554           break;
1555
1556         case ALPHA_R_REFLONG:
1557         case ALPHA_R_REFQUAD:
1558         case ALPHA_R_BRADDR:
1559         case ALPHA_R_HINT:
1560         case ALPHA_R_SREL16:
1561         case ALPHA_R_SREL32:
1562         case ALPHA_R_SREL64:
1563           relocatep = true;
1564           break;
1565
1566         case ALPHA_R_GPREL32:
1567           /* This relocation is used in a switch table.  It is a 32
1568              bit offset from the current GP value.  We must adjust it
1569              by the different between the original GP value and the
1570              current GP value.  */
1571           relocatep = true;
1572           addend = ecoff_data (input_bfd)->gp - gp;
1573           gp_usedp = true;
1574           break;
1575
1576         case ALPHA_R_LITERAL:
1577           /* This is a reference to a literal value, generally
1578              (always?) in the .lita section.  This is a 16 bit GP
1579              relative relocation.  Sometimes the subsequent reloc is a
1580              LITUSE reloc, which indicates how this reloc is used.
1581              This sometimes permits rewriting the two instructions
1582              referred to by the LITERAL and the LITUSE into different
1583              instructions which do not refer to .lita.  This can save
1584              a memory reference, and permits removing a value from
1585              .lita thus saving GP relative space.
1586
1587              We do not these optimizations.  To do them we would need
1588              to arrange to link the .lita section first, so that by
1589              the time we got here we would know the final values to
1590              use.  This would not be particularly difficult, but it is
1591              not currently implemented.  */
1592
1593           /* I believe that the LITERAL reloc will only apply to a ldq
1594              or ldl instruction, so check my assumption.  */
1595           {
1596             unsigned long insn;
1597
1598             insn = bfd_get_32 (input_bfd,
1599                                contents + r_vaddr - input_section->vma);
1600             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1601                         || ((insn >> 26) & 0x3f) == 0x28);
1602           }
1603
1604           relocatep = true;
1605           addend = ecoff_data (input_bfd)->gp - gp;
1606           gp_usedp = true;
1607           break;
1608
1609         case ALPHA_R_LITUSE:
1610           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
1611              does not cause anything to happen, itself.  */
1612           break;
1613
1614         case ALPHA_R_GPDISP:
1615           /* This marks the ldah of an ldah/lda pair which loads the
1616              gp register with the difference of the gp value and the
1617              current location.  The second of the pair is r_symndx
1618              bytes ahead.  It used to be marked with an ALPHA_R_IGNORE
1619              reloc, but OSF/1 3.2 no longer does that.  */
1620           {
1621             unsigned long insn1, insn2;
1622
1623             /* Get the two instructions.  */
1624             insn1 = bfd_get_32 (input_bfd,
1625                                 contents + r_vaddr - input_section->vma);
1626             insn2 = bfd_get_32 (input_bfd,
1627                                 (contents
1628                                  + r_vaddr
1629                                  - input_section->vma
1630                                  + r_symndx));
1631
1632             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1633             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1634
1635             /* Get the existing addend.  We must account for the sign
1636                extension done by lda and ldah.  */
1637             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1638             if (insn1 & 0x8000)
1639               {
1640                 /* This is addend -= 0x100000000 without causing an
1641                    integer overflow on a 32 bit host.  */
1642                 addend -= 0x80000000;
1643                 addend -= 0x80000000;
1644               }
1645             if (insn2 & 0x8000)
1646               addend -= 0x10000;
1647
1648             /* The existing addend includes the difference between the
1649                gp of the input BFD and the address in the input BFD.
1650                We want to change this to the difference between the
1651                final GP and the final address.  */
1652             addend += (gp
1653                        - ecoff_data (input_bfd)->gp
1654                        + input_section->vma
1655                        - (input_section->output_section->vma
1656                           + input_section->output_offset));
1657
1658             /* Change the instructions, accounting for the sign
1659                extension, and write them out.  */
1660             if (addend & 0x8000)
1661               addend += 0x10000;
1662             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1663             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1664
1665             bfd_put_32 (input_bfd, (bfd_vma) insn1,
1666                         contents + r_vaddr - input_section->vma);
1667             bfd_put_32 (input_bfd, (bfd_vma) insn2,
1668                         contents + r_vaddr - input_section->vma + r_symndx);
1669
1670             gp_usedp = true;
1671           }
1672           break;
1673
1674         case ALPHA_R_OP_PUSH:
1675         case ALPHA_R_OP_PSUB:
1676         case ALPHA_R_OP_PRSHIFT:
1677           /* Manipulate values on the reloc evaluation stack.  The
1678              r_vaddr field is not an address in input_section, it is
1679              the current value (including any addend) of the object
1680              being used.  */
1681           if (! r_extern)
1682             {
1683               asection *s;
1684
1685               s = symndx_to_section[r_symndx];
1686               if (s == (asection *) NULL)
1687                 abort ();
1688               addend = s->output_section->vma + s->output_offset - s->vma;
1689             }
1690           else
1691             {
1692               struct ecoff_link_hash_entry *h;
1693
1694               h = sym_hashes[r_symndx];
1695               if (h == (struct ecoff_link_hash_entry *) NULL)
1696                 abort ();
1697
1698               if (! info->relocateable)
1699                 {
1700                   if (h->root.type == bfd_link_hash_defined
1701                       || h->root.type == bfd_link_hash_defweak)
1702                     addend = (h->root.u.def.value
1703                               + h->root.u.def.section->output_section->vma
1704                               + h->root.u.def.section->output_offset);
1705                   else
1706                     {
1707                       /* Note that we pass the address as 0, since we
1708                          do not have a meaningful number for the
1709                          location within the section that is being
1710                          relocated.  */
1711                       if (! ((*info->callbacks->undefined_symbol)
1712                              (info, h->root.root.string, input_bfd,
1713                               input_section, (bfd_vma) 0)))
1714                         return false;
1715                       addend = 0;
1716                     }
1717                 }
1718               else
1719                 {
1720                   if (h->root.type != bfd_link_hash_defined
1721                       && h->root.type != bfd_link_hash_defweak
1722                       && h->indx == -1)
1723                     {
1724                       /* This symbol is not being written out.  Pass
1725                          the address as 0, as with undefined_symbol,
1726                          above.  */
1727                       if (! ((*info->callbacks->unattached_reloc)
1728                              (info, h->root.root.string, input_bfd,
1729                               input_section, (bfd_vma) 0)))
1730                         return false;
1731                     }
1732
1733                   addend = alpha_convert_external_reloc (output_bfd, info,
1734                                                          input_bfd,
1735                                                          ext_rel, h);
1736                 }
1737             }
1738
1739           addend += r_vaddr;
1740
1741           if (info->relocateable)
1742             {
1743               /* Adjust r_vaddr by the addend.  */
1744               bfd_h_put_64 (input_bfd, addend,
1745                             (bfd_byte *) ext_rel->r_vaddr);
1746             }
1747           else
1748             {
1749               switch (r_type)
1750                 {
1751                 case ALPHA_R_OP_PUSH:
1752                   if (tos >= RELOC_STACKSIZE)
1753                     abort ();
1754                   stack[tos++] = addend;
1755                   break;
1756
1757                 case ALPHA_R_OP_PSUB:
1758                   if (tos == 0)
1759                     abort ();
1760                   stack[tos - 1] -= addend;
1761                   break;
1762
1763                 case ALPHA_R_OP_PRSHIFT:
1764                   if (tos == 0)
1765                     abort ();
1766                   stack[tos - 1] >>= addend;
1767                   break;
1768                 }
1769             }
1770
1771           adjust_addrp = false;
1772           break;
1773
1774         case ALPHA_R_OP_STORE:
1775           /* Store a value from the reloc stack into a bitfield.  If
1776              we are generating relocateable output, all we do is
1777              adjust the address of the reloc.  */
1778           if (! info->relocateable)
1779             {
1780               bfd_vma mask;
1781               bfd_vma val;
1782
1783               if (tos == 0)
1784                 abort ();
1785
1786               /* Get the relocation mask.  The separate steps and the
1787                  casts to bfd_vma are attempts to avoid a bug in the
1788                  Alpha OSF 1.3 C compiler.  See reloc.c for more
1789                  details.  */
1790               mask = 1;
1791               mask <<= (bfd_vma) r_size;
1792               mask -= 1;
1793
1794               /* FIXME: I don't know what kind of overflow checking,
1795                  if any, should be done here.  */
1796               val = bfd_get_64 (input_bfd,
1797                                 contents + r_vaddr - input_section->vma);
1798               val &=~ mask << (bfd_vma) r_offset;
1799               val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1800               bfd_put_64 (input_bfd, val,
1801                           contents + r_vaddr - input_section->vma);
1802             }
1803           break;
1804
1805         case ALPHA_R_GPVALUE:
1806           /* I really don't know if this does the right thing.  */
1807           gp = ecoff_data (input_bfd)->gp + r_symndx;
1808           gp_undefined = false;
1809           break;
1810         }
1811
1812       if (relocatep)
1813         {
1814           reloc_howto_type *howto;
1815           struct ecoff_link_hash_entry *h = NULL;
1816           asection *s = NULL;
1817           bfd_vma relocation;
1818           bfd_reloc_status_type r;
1819
1820           /* Perform a relocation.  */
1821
1822           howto = &alpha_howto_table[r_type];
1823
1824           if (r_extern)
1825             {
1826               h = sym_hashes[r_symndx];
1827               /* If h is NULL, that means that there is a reloc
1828                  against an external symbol which we thought was just
1829                  a debugging symbol.  This should not happen.  */
1830               if (h == (struct ecoff_link_hash_entry *) NULL)
1831                 abort ();
1832             }
1833           else
1834             {
1835               if (r_symndx >= NUM_RELOC_SECTIONS)
1836                 s = NULL;
1837               else
1838                 s = symndx_to_section[r_symndx];
1839
1840               if (s == (asection *) NULL)
1841                 abort ();
1842             }
1843
1844           if (info->relocateable)
1845             {
1846               /* We are generating relocateable output, and must
1847                  convert the existing reloc.  */
1848               if (r_extern)
1849                 {
1850                   if (h->root.type != bfd_link_hash_defined
1851                       && h->root.type != bfd_link_hash_defweak
1852                       && h->indx == -1)
1853                     {
1854                       /* This symbol is not being written out.  */
1855                       if (! ((*info->callbacks->unattached_reloc)
1856                              (info, h->root.root.string, input_bfd,
1857                               input_section, r_vaddr - input_section->vma)))
1858                         return false;
1859                     }
1860
1861                   relocation = alpha_convert_external_reloc (output_bfd,
1862                                                              info,
1863                                                              input_bfd,
1864                                                              ext_rel,
1865                                                              h);
1866                 }
1867               else
1868                 {
1869                   /* This is a relocation against a section.  Adjust
1870                      the value by the amount the section moved.  */
1871                   relocation = (s->output_section->vma
1872                                 + s->output_offset
1873                                 - s->vma);
1874                 }
1875
1876               /* If this is PC relative, the existing object file
1877                  appears to already have the reloc worked out.  We
1878                  must subtract out the old value and add in the new
1879                  one.  */
1880               if (howto->pc_relative)
1881                 relocation -= (input_section->output_section->vma
1882                                + input_section->output_offset
1883                                - input_section->vma);
1884
1885               /* Put in any addend.  */
1886               relocation += addend;
1887
1888               /* Adjust the contents.  */
1889               r = _bfd_relocate_contents (howto, input_bfd, relocation,
1890                                           (contents
1891                                            + r_vaddr
1892                                            - input_section->vma));
1893             }
1894           else
1895             {
1896               /* We are producing a final executable.  */
1897               if (r_extern)
1898                 {
1899                   /* This is a reloc against a symbol.  */
1900                   if (h->root.type == bfd_link_hash_defined
1901                       || h->root.type == bfd_link_hash_defweak)
1902                     {
1903                       asection *hsec;
1904
1905                       hsec = h->root.u.def.section;
1906                       relocation = (h->root.u.def.value
1907                                     + hsec->output_section->vma
1908                                     + hsec->output_offset);
1909                     }
1910                   else
1911                     {
1912                       if (! ((*info->callbacks->undefined_symbol)
1913                              (info, h->root.root.string, input_bfd,
1914                               input_section,
1915                               r_vaddr - input_section->vma)))
1916                         return false;
1917                       relocation = 0;
1918                     }
1919                 }
1920               else
1921                 {
1922                   /* This is a reloc against a section.  */
1923                   relocation = (s->output_section->vma
1924                                 + s->output_offset
1925                                 - s->vma);
1926
1927                   /* Adjust a PC relative relocation by removing the
1928                      reference to the original source section.  */
1929                   if (howto->pc_relative)
1930                     relocation += input_section->vma;
1931                 }
1932
1933               r = _bfd_final_link_relocate (howto,
1934                                             input_bfd,
1935                                             input_section,
1936                                             contents,
1937                                             r_vaddr - input_section->vma,
1938                                             relocation,
1939                                             addend);
1940             }
1941
1942           if (r != bfd_reloc_ok)
1943             {
1944               switch (r)
1945                 {
1946                 default:
1947                 case bfd_reloc_outofrange:
1948                   abort ();
1949                 case bfd_reloc_overflow:
1950                   {
1951                     const char *name;
1952
1953                     if (r_extern)
1954                       name = sym_hashes[r_symndx]->root.root.string;
1955                     else
1956                       name = bfd_section_name (input_bfd,
1957                                                symndx_to_section[r_symndx]);
1958                     if (! ((*info->callbacks->reloc_overflow)
1959                            (info, name, alpha_howto_table[r_type].name,
1960                             (bfd_vma) 0, input_bfd, input_section,
1961                             r_vaddr - input_section->vma)))
1962                       return false;
1963                   }
1964                   break;
1965                 }
1966             }
1967         }
1968
1969       if (info->relocateable && adjust_addrp)
1970         {
1971           /* Change the address of the relocation.  */
1972           bfd_h_put_64 (input_bfd,
1973                         (input_section->output_section->vma
1974                          + input_section->output_offset
1975                          - input_section->vma
1976                          + r_vaddr),
1977                         (bfd_byte *) ext_rel->r_vaddr);
1978         }
1979
1980       if (gp_usedp && gp_undefined)
1981         {
1982           if (! ((*info->callbacks->reloc_dangerous)
1983                  (info, "GP relative relocation when GP not defined",
1984                   input_bfd, input_section, r_vaddr - input_section->vma)))
1985             return false;
1986           /* Only give the error once per link.  */
1987           gp = 4;
1988           _bfd_set_gp_value (output_bfd, gp);
1989           gp_undefined = false;
1990         }
1991     }
1992
1993   if (tos != 0)
1994     abort ();
1995
1996   return true;
1997 }
1998 \f
1999 /* Do final adjustments to the filehdr and the aouthdr.  This routine
2000    sets the dynamic bits in the file header.  */
2001
2002 /*ARGSUSED*/
2003 static boolean
2004 alpha_adjust_headers (abfd, fhdr, ahdr)
2005      bfd *abfd;
2006      struct internal_filehdr *fhdr;
2007      struct internal_aouthdr *ahdr;
2008 {
2009   if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2010     fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2011   else if ((abfd->flags & DYNAMIC) != 0)
2012     fhdr->f_flags |= F_ALPHA_SHARABLE;
2013   return true;
2014 }
2015 \f
2016 /* Archive handling.  In OSF/1 (or Digital Unix) v3.2, Digital
2017    introduced archive packing, in which the elements in an archive are
2018    optionally compressed using a simple dictionary scheme.  We know
2019    how to read such archives, but we don't write them.  */
2020
2021 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2022 #define alpha_ecoff_slurp_extended_name_table \
2023   _bfd_ecoff_slurp_extended_name_table
2024 #define alpha_ecoff_construct_extended_name_table \
2025   _bfd_ecoff_construct_extended_name_table
2026 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2027 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2028 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2029 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2030
2031 /* A compressed file uses this instead of ARFMAG.  */
2032
2033 #define ARFZMAG "Z\012"
2034
2035 /* Read an archive header.  This is like the standard routine, but it
2036    also accepts ARFZMAG.  */
2037
2038 static PTR
2039 alpha_ecoff_read_ar_hdr (abfd)
2040      bfd *abfd;
2041 {
2042   struct areltdata *ret;
2043   struct ar_hdr *h;
2044
2045   ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2046   if (ret == NULL)
2047     return NULL;
2048
2049   h = (struct ar_hdr *) ret->arch_header;
2050   if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2051     {
2052       bfd_byte ab[8];
2053
2054       /* This is a compressed file.  We must set the size correctly.
2055          The size is the eight bytes after the dummy file header.  */
2056       if (bfd_seek (abfd, FILHSZ, SEEK_CUR) != 0
2057           || bfd_read (ab, 1, 8, abfd) != 8
2058           || bfd_seek (abfd, - (FILHSZ + 8), SEEK_CUR) != 0)
2059         return NULL;
2060
2061       ret->parsed_size = bfd_h_get_64 (abfd, ab);
2062     }
2063
2064   return (PTR) ret;
2065 }
2066
2067 /* Get an archive element at a specified file position.  This is where
2068    we uncompress the archive element if necessary.  */
2069
2070 static bfd *
2071 alpha_ecoff_get_elt_at_filepos (archive, filepos)
2072      bfd *archive;
2073      file_ptr filepos;
2074 {
2075   bfd *nbfd = NULL;
2076   struct areltdata *tdata;
2077   struct ar_hdr *hdr;
2078   bfd_byte ab[8];
2079   bfd_size_type size;
2080   bfd_byte *buf, *p;
2081   struct bfd_in_memory *bim;
2082
2083   nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2084   if (nbfd == NULL)
2085     goto error_return;
2086
2087   if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2088     {
2089       /* We have already expanded this BFD.  */
2090       return nbfd;
2091     }
2092
2093   tdata = (struct areltdata *) nbfd->arelt_data;
2094   hdr = (struct ar_hdr *) tdata->arch_header;
2095   if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2096     return nbfd;
2097
2098   /* We must uncompress this element.  We do this by copying it into a
2099      memory buffer, and making bfd_read and bfd_seek use that buffer.
2100      This can use a lot of memory, but it's simpler than getting a
2101      temporary file, making that work with the file descriptor caching
2102      code, and making sure that it is deleted at all appropriate
2103      times.  It can be changed if it ever becomes important.  */
2104
2105   /* The compressed file starts with a dummy ECOFF file header.  */
2106   if (bfd_seek (nbfd, FILHSZ, SEEK_SET) != 0)
2107     goto error_return;
2108
2109   /* The next eight bytes are the real file size.  */
2110   if (bfd_read (ab, 1, 8, nbfd) != 8)
2111     goto error_return;
2112   size = bfd_h_get_64 (nbfd, ab);
2113
2114   if (size == 0)
2115     buf = NULL;
2116   else
2117     {
2118       bfd_size_type left;
2119       bfd_byte dict[4096];
2120       unsigned int h;
2121       bfd_byte b;
2122
2123       buf = (bfd_byte *) bfd_alloc (nbfd, size);
2124       if (buf == NULL)
2125         goto error_return;
2126       p = buf;
2127
2128       left = size;
2129
2130       /* I don't know what the next eight bytes are for. */
2131       if (bfd_read (ab, 1, 8, nbfd) != 8)
2132         goto error_return;
2133
2134       /* This is the uncompression algorithm.  It's a simple
2135          dictionary based scheme in which each character is predicted
2136          by a hash of the previous three characters.  A control byte
2137          indicates whether the character is predicted or whether it
2138          appears in the input stream; each control byte manages the
2139          next eight bytes in the output stream.  */
2140       memset (dict, 0, sizeof dict);
2141       h = 0;
2142       while (bfd_read (&b, 1, 1, nbfd) == 1)
2143         {
2144           unsigned int i;
2145
2146           for (i = 0; i < 8; i++, b >>= 1)
2147             {
2148               bfd_byte n;
2149
2150               if ((b & 1) == 0)
2151                 n = dict[h];
2152               else
2153                 {
2154                   if (! bfd_read (&n, 1, 1, nbfd))
2155                     goto error_return;
2156                   dict[h] = n;
2157                 }
2158
2159               *p++ = n;
2160
2161               --left;
2162               if (left == 0)
2163                 break;
2164
2165               h <<= 4;
2166               h ^= n;
2167               h &= sizeof dict - 1;
2168             }
2169
2170           if (left == 0)
2171             break;
2172         }
2173     }
2174
2175   /* Now the uncompressed file contents are in buf.  */
2176   bim = ((struct bfd_in_memory *)
2177          bfd_alloc (nbfd, sizeof (struct bfd_in_memory)));
2178   if (bim == NULL)
2179     goto error_return;
2180   bim->size = size;
2181   bim->buffer = buf;
2182
2183   nbfd->mtime_set = true;
2184   nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2185
2186   nbfd->flags |= BFD_IN_MEMORY;
2187   nbfd->iostream = (PTR) bim;
2188   BFD_ASSERT (! nbfd->cacheable);
2189
2190   return nbfd;
2191
2192  error_return:
2193   if (nbfd != NULL)
2194     bfd_close (nbfd);
2195   return NULL;
2196 }
2197
2198 /* Open the next archived file.  */
2199
2200 static bfd *
2201 alpha_ecoff_openr_next_archived_file (archive, last_file)
2202      bfd *archive;
2203      bfd *last_file;
2204 {
2205   file_ptr filestart;
2206
2207   if (last_file == NULL)
2208     filestart = bfd_ardata (archive)->first_file_filepos;
2209   else
2210     {
2211       struct areltdata *t;
2212       struct ar_hdr *h;
2213       bfd_size_type size;
2214
2215       /* We can't use arelt_size here, because that uses parsed_size,
2216          which is the uncompressed size.  We need the compressed size.  */
2217       t = (struct areltdata *) last_file->arelt_data;
2218       h = (struct ar_hdr *) t->arch_header;
2219       size = strtol (h->ar_size, (char **) NULL, 10);
2220
2221       /* Pad to an even boundary...
2222          Note that last_file->origin can be odd in the case of
2223          BSD-4.4-style element with a long odd size. */
2224       filestart = last_file->origin + size;
2225       filestart += filestart % 2;
2226     }
2227
2228   return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2229 }
2230
2231 /* Open the archive file given an index into the armap.  */
2232
2233 static bfd *
2234 alpha_ecoff_get_elt_at_index (abfd, index)
2235      bfd *abfd;
2236      symindex index;
2237 {
2238   carsym *entry;
2239
2240   entry = bfd_ardata (abfd)->symdefs + index;
2241   return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2242 }
2243 \f
2244 /* This is the ECOFF backend structure.  The backend field of the
2245    target vector points to this.  */
2246
2247 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2248 {
2249   /* COFF backend structure.  */
2250   {
2251     (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2252     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2253     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2254     (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2255     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2256     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2257     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2258     alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2259     alpha_ecoff_swap_scnhdr_out,
2260     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, true,
2261     alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2262     alpha_ecoff_swap_scnhdr_in, NULL,
2263     alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2264     alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2265     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2266     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
2267   },
2268   /* Supported architecture.  */
2269   bfd_arch_alpha,
2270   /* Initial portion of armap string.  */
2271   "________64",
2272   /* The page boundary used to align sections in a demand-paged
2273      executable file.  E.g., 0x1000.  */
2274   0x2000,
2275   /* True if the .rdata section is part of the text segment, as on the
2276      Alpha.  False if .rdata is part of the data segment, as on the
2277      MIPS.  */
2278   true,
2279   /* Bitsize of constructor entries.  */
2280   64,
2281   /* Reloc to use for constructor entries.  */
2282   &alpha_howto_table[ALPHA_R_REFQUAD],
2283   {
2284     /* Symbol table magic number.  */
2285     magicSym2,
2286     /* Alignment of debugging information.  E.g., 4.  */
2287     8,
2288     /* Sizes of external symbolic information.  */
2289     sizeof (struct hdr_ext),
2290     sizeof (struct dnr_ext),
2291     sizeof (struct pdr_ext),
2292     sizeof (struct sym_ext),
2293     sizeof (struct opt_ext),
2294     sizeof (struct fdr_ext),
2295     sizeof (struct rfd_ext),
2296     sizeof (struct ext_ext),
2297     /* Functions to swap in external symbolic data.  */
2298     ecoff_swap_hdr_in,
2299     ecoff_swap_dnr_in,
2300     ecoff_swap_pdr_in,
2301     ecoff_swap_sym_in,
2302     ecoff_swap_opt_in,
2303     ecoff_swap_fdr_in,
2304     ecoff_swap_rfd_in,
2305     ecoff_swap_ext_in,
2306     _bfd_ecoff_swap_tir_in,
2307     _bfd_ecoff_swap_rndx_in,
2308     /* Functions to swap out external symbolic data.  */
2309     ecoff_swap_hdr_out,
2310     ecoff_swap_dnr_out,
2311     ecoff_swap_pdr_out,
2312     ecoff_swap_sym_out,
2313     ecoff_swap_opt_out,
2314     ecoff_swap_fdr_out,
2315     ecoff_swap_rfd_out,
2316     ecoff_swap_ext_out,
2317     _bfd_ecoff_swap_tir_out,
2318     _bfd_ecoff_swap_rndx_out,
2319     /* Function to read in symbolic data.  */
2320     _bfd_ecoff_slurp_symbolic_info
2321   },
2322   /* External reloc size.  */
2323   RELSZ,
2324   /* Reloc swapping functions.  */
2325   alpha_ecoff_swap_reloc_in,
2326   alpha_ecoff_swap_reloc_out,
2327   /* Backend reloc tweaking.  */
2328   alpha_adjust_reloc_in,
2329   alpha_adjust_reloc_out,
2330   /* Relocate section contents while linking.  */
2331   alpha_relocate_section,
2332   /* Do final adjustments to filehdr and aouthdr.  */
2333   alpha_adjust_headers,
2334   /* Read an element from an archive at a given file position.  */
2335   alpha_ecoff_get_elt_at_filepos
2336 };
2337
2338 /* Looking up a reloc type is Alpha specific.  */
2339 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2340
2341 /* So is getting relocated section contents.  */
2342 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2343   alpha_ecoff_get_relocated_section_contents
2344
2345 /* Handling file windows is generic.  */
2346 #define _bfd_ecoff_get_section_contents_in_window \
2347   _bfd_generic_get_section_contents_in_window
2348
2349 /* Relaxing sections is generic.  */
2350 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2351
2352 const bfd_target ecoffalpha_little_vec =
2353 {
2354   "ecoff-littlealpha",          /* name */
2355   bfd_target_ecoff_flavour,
2356   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2357   BFD_ENDIAN_LITTLE,            /* header byte order is little */
2358
2359   (HAS_RELOC | EXEC_P |         /* object flags */
2360    HAS_LINENO | HAS_DEBUG |
2361    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2362
2363   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2364   0,                            /* leading underscore */
2365   ' ',                          /* ar_pad_char */
2366   15,                           /* ar_max_namelen */
2367   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2368      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2369      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2370   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2371      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2372      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2373
2374   {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2375      _bfd_ecoff_archive_p, _bfd_dummy_target},
2376   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2377      _bfd_generic_mkarchive, bfd_false},
2378   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2379      _bfd_write_archive_contents, bfd_false},
2380
2381      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2382      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2383      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2384      BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2385      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2386      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2387      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2388      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2389      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2390
2391   (PTR) &alpha_ecoff_backend_data
2392 };