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