bfd/coff-alpha.c

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