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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.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 FALSE;
 486
 487   return TRUE;
 488 }
 489
 490 /* This is a hook called by coff_real_object_p to create any backend
 491    specific information.  */
 492
 493 static PTR
 494 alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
 495      bfd *abfd;
 496      PTR filehdr;
 497      PTR aouthdr;
 498 {
 499   PTR ecoff;
 500
 501   ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
 502
 503   if (ecoff != NULL)
 504     {
 505       struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 506
 507       /* Set additional BFD flags according to the object type from the
 508          machine specific file header flags.  */
 509       switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
 510         {
 511         case F_ALPHA_SHARABLE:
 512           abfd->flags |= DYNAMIC;
 513           break;
 514         case F_ALPHA_CALL_SHARED:
 515           /* Always executable if using shared libraries as the run time
 516              loader might resolve undefined references.  */
 517           abfd->flags |= (DYNAMIC | EXEC_P);
 518           break;
 519         }
 520     }
 521   return ecoff;
 522 }
 523 \f
 524 /* Reloc handling.  */
 525
 526 /* Swap a reloc in.  */
 527
 528 static void
 529 alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
 530      bfd *abfd;
 531      PTR ext_ptr;
 532      struct internal_reloc *intern;
 533 {
 534   const RELOC *ext = (RELOC *) ext_ptr;
 535
 536   intern->r_vaddr = H_GET_64 (abfd, ext->r_vaddr);
 537   intern->r_symndx = H_GET_32 (abfd, ext->r_symndx);
 538
 539   BFD_ASSERT (bfd_header_little_endian (abfd));
 540
 541   intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
 542                     >> RELOC_BITS0_TYPE_SH_LITTLE);
 543   intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
 544   intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
 545                       >> RELOC_BITS1_OFFSET_SH_LITTLE);
 546   /* Ignored the reserved bits.  */
 547   intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
 548                     >> RELOC_BITS3_SIZE_SH_LITTLE);
 549
 550   if (intern->r_type == ALPHA_R_LITUSE
 551       || intern->r_type == ALPHA_R_GPDISP)
 552     {
 553       /* Handle the LITUSE and GPDISP relocs specially.  Its symndx
 554          value is not actually a symbol index, but is instead a
 555          special code.  We put the code in the r_size field, and
 556          clobber the symndx.  */
 557       if (intern->r_size != 0)
 558         abort ();
 559       intern->r_size = intern->r_symndx;
 560       intern->r_symndx = RELOC_SECTION_NONE;
 561     }
 562   else if (intern->r_type == ALPHA_R_IGNORE)
 563     {
 564       /* The IGNORE reloc generally follows a GPDISP reloc, and is
 565          against the .lita section.  The section is irrelevant.  */
 566       if (! intern->r_extern &&
 567           intern->r_symndx == RELOC_SECTION_ABS)
 568         abort ();
 569       if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
 570         intern->r_symndx = RELOC_SECTION_ABS;
 571     }
 572 }
 573
 574 /* Swap a reloc out.  */
 575
 576 static void
 577 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
 578      bfd *abfd;
 579      const struct internal_reloc *intern;
 580      PTR dst;
 581 {
 582   RELOC *ext = (RELOC *) dst;
 583   long symndx;
 584   unsigned char size;
 585
 586   /* Undo the hackery done in swap_reloc_in.  */
 587   if (intern->r_type == ALPHA_R_LITUSE
 588       || intern->r_type == ALPHA_R_GPDISP)
 589     {
 590       symndx = intern->r_size;
 591       size = 0;
 592     }
 593   else if (intern->r_type == ALPHA_R_IGNORE
 594            && ! intern->r_extern
 595            && intern->r_symndx == RELOC_SECTION_ABS)
 596     {
 597       symndx = RELOC_SECTION_LITA;
 598       size = intern->r_size;
 599     }
 600   else
 601     {
 602       symndx = intern->r_symndx;
 603       size = intern->r_size;
 604     }
 605
 606   BFD_ASSERT (intern->r_extern
 607               || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
 608
 609   H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr);
 610   H_PUT_32 (abfd, symndx, ext->r_symndx);
 611
 612   BFD_ASSERT (bfd_header_little_endian (abfd));
 613
 614   ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
 615                     & RELOC_BITS0_TYPE_LITTLE);
 616   ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
 617                     | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
 618                        & RELOC_BITS1_OFFSET_LITTLE));
 619   ext->r_bits[2] = 0;
 620   ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
 621                     & RELOC_BITS3_SIZE_LITTLE);
 622 }
 623
 624 /* Finish canonicalizing a reloc.  Part of this is generic to all
 625    ECOFF targets, and that part is in ecoff.c.  The rest is done in
 626    this backend routine.  It must fill in the howto field.  */
 627
 628 static void
 629 alpha_adjust_reloc_in (abfd, intern, rptr)
 630      bfd *abfd;
 631      const struct internal_reloc *intern;
 632      arelent *rptr;
 633 {
 634   if (intern->r_type > ALPHA_R_GPVALUE)
 635     abort ();
 636
 637   switch (intern->r_type)
 638     {
 639     case ALPHA_R_BRADDR:
 640     case ALPHA_R_SREL16:
 641     case ALPHA_R_SREL32:
 642     case ALPHA_R_SREL64:
 643       /* This relocs appear to be fully resolved when they are against
 644          internal symbols.  Against external symbols, BRADDR at least
 645          appears to be resolved against the next instruction.  */
 646       if (! intern->r_extern)
 647         rptr->addend = 0;
 648       else
 649         rptr->addend = - (intern->r_vaddr + 4);
 650       break;
 651
 652     case ALPHA_R_GPREL32:
 653     case ALPHA_R_LITERAL:
 654       /* Copy the gp value for this object file into the addend, to
 655          ensure that we are not confused by the linker.  */
 656       if (! intern->r_extern)
 657         rptr->addend += ecoff_data (abfd)->gp;
 658       break;
 659
 660     case ALPHA_R_LITUSE:
 661     case ALPHA_R_GPDISP:
 662       /* The LITUSE and GPDISP relocs do not use a symbol, or an
 663          addend, but they do use a special code.  Put this code in the
 664          addend field.  */
 665       rptr->addend = intern->r_size;
 666       break;
 667
 668     case ALPHA_R_OP_STORE:
 669       /* The STORE reloc needs the size and offset fields.  We store
 670          them in the addend.  */
 671       BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
 672       rptr->addend = (intern->r_offset << 8) + intern->r_size;
 673       break;
 674
 675     case ALPHA_R_OP_PUSH:
 676     case ALPHA_R_OP_PSUB:
 677     case ALPHA_R_OP_PRSHIFT:
 678       /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
 679          address.  I believe that the address supplied is really an
 680          addend.  */
 681       rptr->addend = intern->r_vaddr;
 682       break;
 683
 684     case ALPHA_R_GPVALUE:
 685       /* Set the addend field to the new GP value.  */
 686       rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
 687       break;
 688
 689     case ALPHA_R_IGNORE:
 690       /* If the type is ALPHA_R_IGNORE, make sure this is a reference
 691          to the absolute section so that the reloc is ignored.  For
 692          some reason the address of this reloc type is not adjusted by
 693          the section vma.  We record the gp value for this object file
 694          here, for convenience when doing the GPDISP relocation.  */
 695       rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 696       rptr->address = intern->r_vaddr;
 697       rptr->addend = ecoff_data (abfd)->gp;
 698       break;
 699
 700     default:
 701       break;
 702     }
 703
 704   rptr->howto = &alpha_howto_table[intern->r_type];
 705 }
 706
 707 /* When writing out a reloc we need to pull some values back out of
 708    the addend field into the reloc.  This is roughly the reverse of
 709    alpha_adjust_reloc_in, except that there are several changes we do
 710    not need to undo.  */
 711
 712 static void
 713 alpha_adjust_reloc_out (abfd, rel, intern)
 714      bfd *abfd ATTRIBUTE_UNUSED;
 715      const arelent *rel;
 716      struct internal_reloc *intern;
 717 {
 718   switch (intern->r_type)
 719     {
 720     case ALPHA_R_LITUSE:
 721     case ALPHA_R_GPDISP:
 722       intern->r_size = rel->addend;
 723       break;
 724
 725     case ALPHA_R_OP_STORE:
 726       intern->r_size = rel->addend & 0xff;
 727       intern->r_offset = (rel->addend >> 8) & 0xff;
 728       break;
 729
 730     case ALPHA_R_OP_PUSH:
 731     case ALPHA_R_OP_PSUB:
 732     case ALPHA_R_OP_PRSHIFT:
 733       intern->r_vaddr = rel->addend;
 734       break;
 735
 736     case ALPHA_R_IGNORE:
 737       intern->r_vaddr = rel->address;
 738       break;
 739
 740     default:
 741       break;
 742     }
 743 }
 744
 745 /* The size of the stack for the relocation evaluator.  */
 746 #define RELOC_STACKSIZE (10)
 747
 748 /* Alpha ECOFF relocs have a built in expression evaluator as well as
 749    other interdependencies.  Rather than use a bunch of special
 750    functions and global variables, we use a single routine to do all
 751    the relocation for a section.  I haven't yet worked out how the
 752    assembler is going to handle this.  */
 753
 754 static bfd_byte *
 755 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
 756                                             data, relocatable, symbols)
 757      bfd *abfd;
 758      struct bfd_link_info *link_info;
 759      struct bfd_link_order *link_order;
 760      bfd_byte *data;
 761      bfd_boolean relocatable;
 762      asymbol **symbols;
 763 {
 764   bfd *input_bfd = link_order->u.indirect.section->owner;
 765   asection *input_section = link_order->u.indirect.section;
 766   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
 767   arelent **reloc_vector = NULL;
 768   long reloc_count;
 769   bfd *output_bfd = relocatable ? abfd : (bfd *) NULL;
 770   bfd_vma gp;
 771   bfd_size_type sz;
 772   bfd_boolean gp_undefined;
 773   bfd_vma stack[RELOC_STACKSIZE];
 774   int tos = 0;
 775
 776   if (reloc_size < 0)
 777     goto error_return;
 778   reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
 779   if (reloc_vector == NULL && reloc_size != 0)
 780     goto error_return;
 781
 782   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
 783   if (! bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
 784     goto error_return;
 785
 786   reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
 787                                         reloc_vector, symbols);
 788   if (reloc_count < 0)
 789     goto error_return;
 790   if (reloc_count == 0)
 791     goto successful_return;
 792
 793   /* Get the GP value for the output BFD.  */
 794   gp_undefined = FALSE;
 795   gp = _bfd_get_gp_value (abfd);
 796   if (gp == 0)
 797     {
 798       if (relocatable)
 799         {
 800           asection *sec;
 801           bfd_vma lo;
 802
 803           /* Make up a value.  */
 804           lo = (bfd_vma) -1;
 805           for (sec = abfd->sections; sec != NULL; sec = sec->next)
 806             {
 807               if (sec->vma < lo
 808                   && (strcmp (sec->name, ".sbss") == 0
 809                       || strcmp (sec->name, ".sdata") == 0
 810                       || strcmp (sec->name, ".lit4") == 0
 811                       || strcmp (sec->name, ".lit8") == 0
 812                       || strcmp (sec->name, ".lita") == 0))
 813                 lo = sec->vma;
 814             }
 815           gp = lo + 0x8000;
 816           _bfd_set_gp_value (abfd, gp);
 817         }
 818       else
 819         {
 820           struct bfd_link_hash_entry *h;
 821
 822           h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE,
 823                                     TRUE);
 824           if (h == (struct bfd_link_hash_entry *) NULL
 825               || h->type != bfd_link_hash_defined)
 826             gp_undefined = TRUE;
 827           else
 828             {
 829               gp = (h->u.def.value
 830                     + h->u.def.section->output_section->vma
 831                     + h->u.def.section->output_offset);
 832               _bfd_set_gp_value (abfd, gp);
 833             }
 834         }
 835     }
 836
 837   for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
 838     {
 839       arelent *rel;
 840       bfd_reloc_status_type r;
 841       char *err;
 842
 843       rel = *reloc_vector;
 844       r = bfd_reloc_ok;
 845       switch (rel->howto->type)
 846         {
 847         case ALPHA_R_IGNORE:
 848           rel->address += input_section->output_offset;
 849           break;
 850
 851         case ALPHA_R_REFLONG:
 852         case ALPHA_R_REFQUAD:
 853         case ALPHA_R_BRADDR:
 854         case ALPHA_R_HINT:
 855         case ALPHA_R_SREL16:
 856         case ALPHA_R_SREL32:
 857         case ALPHA_R_SREL64:
 858           if (relocatable
 859               && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
 860             {
 861               rel->address += input_section->output_offset;
 862               break;
 863             }
 864           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 865                                       output_bfd, &err);
 866           break;
 867
 868         case ALPHA_R_GPREL32:
 869           /* This relocation is used in a switch table.  It is a 32
 870              bit offset from the current GP value.  We must adjust it
 871              by the different between the original GP value and the
 872              current GP value.  The original GP value is stored in the
 873              addend.  We adjust the addend and let
 874              bfd_perform_relocation finish the job.  */
 875           rel->addend -= gp;
 876           r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 877                                       output_bfd, &err);
 878           if (r == bfd_reloc_ok && gp_undefined)
 879             {
 880               r = bfd_reloc_dangerous;
 881               err = (char *) _("GP relative relocation used when GP not defined");
 882             }
 883           break;
 884
 885         case ALPHA_R_LITERAL:
 886           /* This is a reference to a literal value, generally
 887              (always?) in the .lita section.  This is a 16 bit GP
 888              relative relocation.  Sometimes the subsequent reloc is a
 889              LITUSE reloc, which indicates how this reloc is used.
 890              This sometimes permits rewriting the two instructions
 891              referred to by the LITERAL and the LITUSE into different
 892              instructions which do not refer to .lita.  This can save
 893              a memory reference, and permits removing a value from
 894              .lita thus saving GP relative space.
 895
 896              We do not these optimizations.  To do them we would need
 897              to arrange to link the .lita section first, so that by
 898              the time we got here we would know the final values to
 899              use.  This would not be particularly difficult, but it is
 900              not currently implemented.  */
 901
 902           {
 903             unsigned long insn;
 904
 905             /* I believe that the LITERAL reloc will only apply to a
 906                ldq or ldl instruction, so check my assumption.  */
 907             insn = bfd_get_32 (input_bfd, data + rel->address);
 908             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
 909                         || ((insn >> 26) & 0x3f) == 0x28);
 910
 911             rel->addend -= gp;
 912             r = bfd_perform_relocation (input_bfd, rel, data, input_section,
 913                                         output_bfd, &err);
 914             if (r == bfd_reloc_ok && gp_undefined)
 915               {
 916                 r = bfd_reloc_dangerous;
 917                 err =
 918                   (char *) _("GP relative relocation used when GP not defined");
 919               }
 920           }
 921           break;
 922
 923         case ALPHA_R_LITUSE:
 924           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
 925              does not cause anything to happen, itself.  */
 926           rel->address += input_section->output_offset;
 927           break;
 928
 929         case ALPHA_R_GPDISP:
 930           /* This marks the ldah of an ldah/lda pair which loads the
 931              gp register with the difference of the gp value and the
 932              current location.  The second of the pair is r_size bytes
 933              ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
 934              but that no longer happens in OSF/1 3.2.  */
 935           {
 936             unsigned long insn1, insn2;
 937             bfd_vma addend;
 938
 939             /* Get the two instructions.  */
 940             insn1 = bfd_get_32 (input_bfd, data + rel->address);
 941             insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
 942
 943             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
 944             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
 945
 946             /* Get the existing addend.  We must account for the sign
 947                extension done by lda and ldah.  */
 948             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
 949             if (insn1 & 0x8000)
 950               {
 951                 addend -= 0x80000000;
 952                 addend -= 0x80000000;
 953               }
 954             if (insn2 & 0x8000)
 955               addend -= 0x10000;
 956
 957             /* The existing addend includes the different between the
 958                gp of the input BFD and the address in the input BFD.
 959                Subtract this out.  */
 960             addend -= (ecoff_data (input_bfd)->gp
 961                        - (input_section->vma + rel->address));
 962
 963             /* Now add in the final gp value, and subtract out the
 964                final address.  */
 965             addend += (gp
 966                        - (input_section->output_section->vma
 967                           + input_section->output_offset
 968                           + rel->address));
 969
 970             /* Change the instructions, accounting for the sign
 971                extension, and write them out.  */
 972             if (addend & 0x8000)
 973               addend += 0x10000;
 974             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
 975             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
 976
 977             bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
 978             bfd_put_32 (input_bfd, (bfd_vma) insn2,
 979                         data + rel->address + rel->addend);
 980
 981             rel->address += input_section->output_offset;
 982           }
 983           break;
 984
 985         case ALPHA_R_OP_PUSH:
 986           /* Push a value on the reloc evaluation stack.  */
 987           {
 988             asymbol *symbol;
 989             bfd_vma relocation;
 990
 991             if (relocatable)
 992               {
 993                 rel->address += input_section->output_offset;
 994                 break;
 995               }
 996
 997             /* Figure out the relocation of this symbol.  */
 998             symbol = *rel->sym_ptr_ptr;
 999
1000             if (bfd_is_und_section (symbol->section))
1001               r = bfd_reloc_undefined;
1002
1003             if (bfd_is_com_section (symbol->section))
1004               relocation = 0;
1005             else
1006               relocation = symbol->value;
1007             relocation += symbol->section->output_section->vma;
1008             relocation += symbol->section->output_offset;
1009             relocation += rel->addend;
1010
1011             if (tos >= RELOC_STACKSIZE)
1012               abort ();
1013
1014             stack[tos++] = relocation;
1015           }
1016           break;
1017
1018         case ALPHA_R_OP_STORE:
1019           /* Store a value from the reloc stack into a bitfield.  */
1020           {
1021             bfd_vma val;
1022             int offset, size;
1023
1024             if (relocatable)
1025               {
1026                 rel->address += input_section->output_offset;
1027                 break;
1028               }
1029
1030             if (tos == 0)
1031               abort ();
1032
1033             /* The offset and size for this reloc are encoded into the
1034                addend field by alpha_adjust_reloc_in.  */
1035             offset = (rel->addend >> 8) & 0xff;
1036             size = rel->addend & 0xff;
1037
1038             val = bfd_get_64 (abfd, data + rel->address);
1039             val &=~ (((1 << size) - 1) << offset);
1040             val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1041             bfd_put_64 (abfd, val, data + rel->address);
1042           }
1043           break;
1044
1045         case ALPHA_R_OP_PSUB:
1046           /* Subtract a value from the top of the stack.  */
1047           {
1048             asymbol *symbol;
1049             bfd_vma relocation;
1050
1051             if (relocatable)
1052               {
1053                 rel->address += input_section->output_offset;
1054                 break;
1055               }
1056
1057             /* Figure out the relocation of this symbol.  */
1058             symbol = *rel->sym_ptr_ptr;
1059
1060             if (bfd_is_und_section (symbol->section))
1061               r = bfd_reloc_undefined;
1062
1063             if (bfd_is_com_section (symbol->section))
1064               relocation = 0;
1065             else
1066               relocation = symbol->value;
1067             relocation += symbol->section->output_section->vma;
1068             relocation += symbol->section->output_offset;
1069             relocation += rel->addend;
1070
1071             if (tos == 0)
1072               abort ();
1073
1074             stack[tos - 1] -= relocation;
1075           }
1076           break;
1077
1078         case ALPHA_R_OP_PRSHIFT:
1079           /* Shift the value on the top of the stack.  */
1080           {
1081             asymbol *symbol;
1082             bfd_vma relocation;
1083
1084             if (relocatable)
1085               {
1086                 rel->address += input_section->output_offset;
1087                 break;
1088               }
1089
1090             /* Figure out the relocation of this symbol.  */
1091             symbol = *rel->sym_ptr_ptr;
1092
1093             if (bfd_is_und_section (symbol->section))
1094               r = bfd_reloc_undefined;
1095
1096             if (bfd_is_com_section (symbol->section))
1097               relocation = 0;
1098             else
1099               relocation = symbol->value;
1100             relocation += symbol->section->output_section->vma;
1101             relocation += symbol->section->output_offset;
1102             relocation += rel->addend;
1103
1104             if (tos == 0)
1105               abort ();
1106
1107             stack[tos - 1] >>= relocation;
1108           }
1109           break;
1110
1111         case ALPHA_R_GPVALUE:
1112           /* I really don't know if this does the right thing.  */
1113           gp = rel->addend;
1114           gp_undefined = FALSE;
1115           break;
1116
1117         default:
1118           abort ();
1119         }
1120
1121       if (relocatable)
1122         {
1123           asection *os = input_section->output_section;
1124
1125           /* A partial link, so keep the relocs.  */
1126           os->orelocation[os->reloc_count] = rel;
1127           os->reloc_count++;
1128         }
1129
1130       if (r != bfd_reloc_ok)
1131         {
1132           switch (r)
1133             {
1134             case bfd_reloc_undefined:
1135               if (! ((*link_info->callbacks->undefined_symbol)
1136                      (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1137                       input_bfd, input_section, rel->address, TRUE)))
1138                 goto error_return;
1139               break;
1140             case bfd_reloc_dangerous:
1141               if (! ((*link_info->callbacks->reloc_dangerous)
1142                      (link_info, err, input_bfd, input_section,
1143                       rel->address)))
1144                 goto error_return;
1145               break;
1146             case bfd_reloc_overflow:
1147               if (! ((*link_info->callbacks->reloc_overflow)
1148                      (link_info, NULL,
1149                       bfd_asymbol_name (*rel->sym_ptr_ptr),
1150                       rel->howto->name, rel->addend, input_bfd,
1151                       input_section, rel->address)))
1152                 goto error_return;
1153               break;
1154             case bfd_reloc_outofrange:
1155             default:
1156               abort ();
1157               break;
1158             }
1159         }
1160     }
1161
1162   if (tos != 0)
1163     abort ();
1164
1165  successful_return:
1166   if (reloc_vector != NULL)
1167     free (reloc_vector);
1168   return data;
1169
1170  error_return:
1171   if (reloc_vector != NULL)
1172     free (reloc_vector);
1173   return NULL;
1174 }
1175
1176 /* Get the howto structure for a generic reloc type.  */
1177
1178 static reloc_howto_type *
1179 alpha_bfd_reloc_type_lookup (abfd, code)
1180      bfd *abfd ATTRIBUTE_UNUSED;
1181      bfd_reloc_code_real_type code;
1182 {
1183   int alpha_type;
1184
1185   switch (code)
1186     {
1187     case BFD_RELOC_32:
1188       alpha_type = ALPHA_R_REFLONG;
1189       break;
1190     case BFD_RELOC_64:
1191     case BFD_RELOC_CTOR:
1192       alpha_type = ALPHA_R_REFQUAD;
1193       break;
1194     case BFD_RELOC_GPREL32:
1195       alpha_type = ALPHA_R_GPREL32;
1196       break;
1197     case BFD_RELOC_ALPHA_LITERAL:
1198       alpha_type = ALPHA_R_LITERAL;
1199       break;
1200     case BFD_RELOC_ALPHA_LITUSE:
1201       alpha_type = ALPHA_R_LITUSE;
1202       break;
1203     case BFD_RELOC_ALPHA_GPDISP_HI16:
1204       alpha_type = ALPHA_R_GPDISP;
1205       break;
1206     case BFD_RELOC_ALPHA_GPDISP_LO16:
1207       alpha_type = ALPHA_R_IGNORE;
1208       break;
1209     case BFD_RELOC_23_PCREL_S2:
1210       alpha_type = ALPHA_R_BRADDR;
1211       break;
1212     case BFD_RELOC_ALPHA_HINT:
1213       alpha_type = ALPHA_R_HINT;
1214       break;
1215     case BFD_RELOC_16_PCREL:
1216       alpha_type = ALPHA_R_SREL16;
1217       break;
1218     case BFD_RELOC_32_PCREL:
1219       alpha_type = ALPHA_R_SREL32;
1220       break;
1221     case BFD_RELOC_64_PCREL:
1222       alpha_type = ALPHA_R_SREL64;
1223       break;
1224 #if 0
1225     case ???:
1226       alpha_type = ALPHA_R_OP_PUSH;
1227       break;
1228     case ???:
1229       alpha_type = ALPHA_R_OP_STORE;
1230       break;
1231     case ???:
1232       alpha_type = ALPHA_R_OP_PSUB;
1233       break;
1234     case ???:
1235       alpha_type = ALPHA_R_OP_PRSHIFT;
1236       break;
1237     case ???:
1238       alpha_type = ALPHA_R_GPVALUE;
1239       break;
1240 #endif
1241     default:
1242       return (reloc_howto_type *) NULL;
1243     }
1244
1245   return &alpha_howto_table[alpha_type];
1246 }
1247 \f
1248 /* A helper routine for alpha_relocate_section which converts an
1249    external reloc when generating relocatable output.  Returns the
1250    relocation amount.  */
1251
1252 static bfd_vma
1253 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1254      bfd *output_bfd ATTRIBUTE_UNUSED;
1255      struct bfd_link_info *info;
1256      bfd *input_bfd;
1257      struct external_reloc *ext_rel;
1258      struct ecoff_link_hash_entry *h;
1259 {
1260   unsigned long r_symndx;
1261   bfd_vma relocation;
1262
1263   BFD_ASSERT (info->relocatable);
1264
1265   if (h->root.type == bfd_link_hash_defined
1266       || h->root.type == bfd_link_hash_defweak)
1267     {
1268       asection *hsec;
1269       const char *name;
1270
1271       /* This symbol is defined in the output.  Convert the reloc from
1272          being against the symbol to being against the section.  */
1273
1274       /* Clear the r_extern bit.  */
1275       ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1276
1277       /* Compute a new r_symndx value.  */
1278       hsec = h->root.u.def.section;
1279       name = bfd_get_section_name (output_bfd, hsec->output_section);
1280
1281       r_symndx = (unsigned long) -1;
1282       switch (name[1])
1283         {
1284         case 'A':
1285           if (strcmp (name, "*ABS*") == 0)
1286             r_symndx = RELOC_SECTION_ABS;
1287           break;
1288         case 'b':
1289           if (strcmp (name, ".bss") == 0)
1290             r_symndx = RELOC_SECTION_BSS;
1291           break;
1292         case 'd':
1293           if (strcmp (name, ".data") == 0)
1294             r_symndx = RELOC_SECTION_DATA;
1295           break;
1296         case 'f':
1297           if (strcmp (name, ".fini") == 0)
1298             r_symndx = RELOC_SECTION_FINI;
1299           break;
1300         case 'i':
1301           if (strcmp (name, ".init") == 0)
1302             r_symndx = RELOC_SECTION_INIT;
1303           break;
1304         case 'l':
1305           if (strcmp (name, ".lita") == 0)
1306             r_symndx = RELOC_SECTION_LITA;
1307           else if (strcmp (name, ".lit8") == 0)
1308             r_symndx = RELOC_SECTION_LIT8;
1309           else if (strcmp (name, ".lit4") == 0)
1310             r_symndx = RELOC_SECTION_LIT4;
1311           break;
1312         case 'p':
1313           if (strcmp (name, ".pdata") == 0)
1314             r_symndx = RELOC_SECTION_PDATA;
1315           break;
1316         case 'r':
1317           if (strcmp (name, ".rdata") == 0)
1318             r_symndx = RELOC_SECTION_RDATA;
1319           else if (strcmp (name, ".rconst") == 0)
1320             r_symndx = RELOC_SECTION_RCONST;
1321           break;
1322         case 's':
1323           if (strcmp (name, ".sdata") == 0)
1324             r_symndx = RELOC_SECTION_SDATA;
1325           else if (strcmp (name, ".sbss") == 0)
1326             r_symndx = RELOC_SECTION_SBSS;
1327           break;
1328         case 't':
1329           if (strcmp (name, ".text") == 0)
1330             r_symndx = RELOC_SECTION_TEXT;
1331           break;
1332         case 'x':
1333           if (strcmp (name, ".xdata") == 0)
1334             r_symndx = RELOC_SECTION_XDATA;
1335           break;
1336         }
1337
1338       if (r_symndx == (unsigned long) -1)
1339         abort ();
1340
1341       /* Add the section VMA and the symbol value.  */
1342       relocation = (h->root.u.def.value
1343                     + hsec->output_section->vma
1344                     + hsec->output_offset);
1345     }
1346   else
1347     {
1348       /* Change the symndx value to the right one for
1349          the output BFD.  */
1350       r_symndx = h->indx;
1351       if (r_symndx == (unsigned long) -1)
1352         {
1353           /* Caller must give an error.  */
1354           r_symndx = 0;
1355         }
1356       relocation = 0;
1357     }
1358
1359   /* Write out the new r_symndx value.  */
1360   H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx);
1361
1362   return relocation;
1363 }
1364
1365 /* Relocate a section while linking an Alpha ECOFF file.  This is
1366    quite similar to get_relocated_section_contents.  Perhaps they
1367    could be combined somehow.  */
1368
1369 static bfd_boolean
1370 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1371                         contents, external_relocs)
1372      bfd *output_bfd;
1373      struct bfd_link_info *info;
1374      bfd *input_bfd;
1375      asection *input_section;
1376      bfd_byte *contents;
1377      PTR external_relocs;
1378 {
1379   asection **symndx_to_section, *lita_sec;
1380   struct ecoff_link_hash_entry **sym_hashes;
1381   bfd_vma gp;
1382   bfd_boolean gp_undefined;
1383   bfd_vma stack[RELOC_STACKSIZE];
1384   int tos = 0;
1385   struct external_reloc *ext_rel;
1386   struct external_reloc *ext_rel_end;
1387   bfd_size_type amt;
1388
1389   /* We keep a table mapping the symndx found in an internal reloc to
1390      the appropriate section.  This is faster than looking up the
1391      section by name each time.  */
1392   symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1393   if (symndx_to_section == (asection **) NULL)
1394     {
1395       amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1396       symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1397       if (!symndx_to_section)
1398         return FALSE;
1399
1400       symndx_to_section[RELOC_SECTION_NONE] = NULL;
1401       symndx_to_section[RELOC_SECTION_TEXT] =
1402         bfd_get_section_by_name (input_bfd, ".text");
1403       symndx_to_section[RELOC_SECTION_RDATA] =
1404         bfd_get_section_by_name (input_bfd, ".rdata");
1405       symndx_to_section[RELOC_SECTION_DATA] =
1406         bfd_get_section_by_name (input_bfd, ".data");
1407       symndx_to_section[RELOC_SECTION_SDATA] =
1408         bfd_get_section_by_name (input_bfd, ".sdata");
1409       symndx_to_section[RELOC_SECTION_SBSS] =
1410         bfd_get_section_by_name (input_bfd, ".sbss");
1411       symndx_to_section[RELOC_SECTION_BSS] =
1412         bfd_get_section_by_name (input_bfd, ".bss");
1413       symndx_to_section[RELOC_SECTION_INIT] =
1414         bfd_get_section_by_name (input_bfd, ".init");
1415       symndx_to_section[RELOC_SECTION_LIT8] =
1416         bfd_get_section_by_name (input_bfd, ".lit8");
1417       symndx_to_section[RELOC_SECTION_LIT4] =
1418         bfd_get_section_by_name (input_bfd, ".lit4");
1419       symndx_to_section[RELOC_SECTION_XDATA] =
1420         bfd_get_section_by_name (input_bfd, ".xdata");
1421       symndx_to_section[RELOC_SECTION_PDATA] =
1422         bfd_get_section_by_name (input_bfd, ".pdata");
1423       symndx_to_section[RELOC_SECTION_FINI] =
1424         bfd_get_section_by_name (input_bfd, ".fini");
1425       symndx_to_section[RELOC_SECTION_LITA] =
1426         bfd_get_section_by_name (input_bfd, ".lita");
1427       symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1428       symndx_to_section[RELOC_SECTION_RCONST] =
1429         bfd_get_section_by_name (input_bfd, ".rconst");
1430
1431       ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1432     }
1433
1434   sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1435
1436   /* On the Alpha, the .lita section must be addressable by the global
1437      pointer.  To support large programs, we need to allow multiple
1438      global pointers.  This works as long as each input .lita section
1439      is <64KB big.  This implies that when producing relocatable
1440      output, the .lita section is limited to 64KB. .  */
1441
1442   lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1443   gp = _bfd_get_gp_value (output_bfd);
1444   if (! info->relocatable && lita_sec != NULL)
1445     {
1446       struct ecoff_section_tdata *lita_sec_data;
1447
1448       /* Make sure we have a section data structure to which we can
1449          hang on to the gp value we pick for the section.  */
1450       lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1451       if (lita_sec_data == NULL)
1452         {
1453           amt = sizeof (struct ecoff_section_tdata);
1454           lita_sec_data = ((struct ecoff_section_tdata *)
1455                            bfd_zalloc (input_bfd, amt));
1456           lita_sec->used_by_bfd = lita_sec_data;
1457         }
1458
1459       if (lita_sec_data->gp != 0)
1460         {
1461           /* If we already assigned a gp to this section, we better
1462              stick with that value.  */
1463           gp = lita_sec_data->gp;
1464         }
1465       else
1466         {
1467           bfd_vma lita_vma;
1468           bfd_size_type lita_size;
1469
1470           lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1471           lita_size = lita_sec->size;
1472
1473           if (gp == 0
1474               || lita_vma <  gp - 0x8000
1475               || lita_vma + lita_size >= gp + 0x8000)
1476             {
1477               /* Either gp hasn't been set at all or the current gp
1478                  cannot address this .lita section.  In both cases we
1479                  reset the gp to point into the "middle" of the
1480                  current input .lita section.  */
1481               if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1482                 {
1483                   (*info->callbacks->warning) (info,
1484                                                _("using multiple gp values"),
1485                                                (char *) NULL, output_bfd,
1486                                                (asection *) NULL, (bfd_vma) 0);
1487                   ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE;
1488                 }
1489               if (lita_vma < gp - 0x8000)
1490                 gp = lita_vma + lita_size - 0x8000;
1491               else
1492                 gp = lita_vma + 0x8000;
1493
1494             }
1495
1496           lita_sec_data->gp = gp;
1497         }
1498
1499       _bfd_set_gp_value (output_bfd, gp);
1500     }
1501
1502   gp_undefined = (gp == 0);
1503
1504   BFD_ASSERT (bfd_header_little_endian (output_bfd));
1505   BFD_ASSERT (bfd_header_little_endian (input_bfd));
1506
1507   ext_rel = (struct external_reloc *) external_relocs;
1508   ext_rel_end = ext_rel + input_section->reloc_count;
1509   for (; ext_rel < ext_rel_end; ext_rel++)
1510     {
1511       bfd_vma r_vaddr;
1512       unsigned long r_symndx;
1513       int r_type;
1514       int r_extern;
1515       int r_offset;
1516       int r_size;
1517       bfd_boolean relocatep;
1518       bfd_boolean adjust_addrp;
1519       bfd_boolean gp_usedp;
1520       bfd_vma addend;
1521
1522       r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr);
1523       r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx);
1524
1525       r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1526                 >> RELOC_BITS0_TYPE_SH_LITTLE);
1527       r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1528       r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1529                   >> RELOC_BITS1_OFFSET_SH_LITTLE);
1530       /* Ignored the reserved bits.  */
1531       r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1532                 >> RELOC_BITS3_SIZE_SH_LITTLE);
1533
1534       relocatep = FALSE;
1535       adjust_addrp = TRUE;
1536       gp_usedp = FALSE;
1537       addend = 0;
1538
1539       switch (r_type)
1540         {
1541         default:
1542           abort ();
1543
1544         case ALPHA_R_IGNORE:
1545           /* This reloc appears after a GPDISP reloc.  On earlier
1546              versions of OSF/1, It marked the position of the second
1547              instruction to be altered by the GPDISP reloc, but it is
1548              not otherwise used for anything.  For some reason, the
1549              address of the relocation does not appear to include the
1550              section VMA, unlike the other relocation types.  */
1551           if (info->relocatable)
1552             H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr,
1553                       ext_rel->r_vaddr);
1554           adjust_addrp = FALSE;
1555           break;
1556
1557         case ALPHA_R_REFLONG:
1558         case ALPHA_R_REFQUAD:
1559         case ALPHA_R_HINT:
1560           relocatep = TRUE;
1561           break;
1562
1563         case ALPHA_R_BRADDR:
1564         case ALPHA_R_SREL16:
1565         case ALPHA_R_SREL32:
1566         case ALPHA_R_SREL64:
1567           if (r_extern)
1568             addend += - (r_vaddr + 4);
1569           relocatep = TRUE;
1570           break;
1571
1572         case ALPHA_R_GPREL32:
1573           /* This relocation is used in a switch table.  It is a 32
1574              bit offset from the current GP value.  We must adjust it
1575              by the different between the original GP value and the
1576              current GP value.  */
1577           relocatep = TRUE;
1578           addend = ecoff_data (input_bfd)->gp - gp;
1579           gp_usedp = TRUE;
1580           break;
1581
1582         case ALPHA_R_LITERAL:
1583           /* This is a reference to a literal value, generally
1584              (always?) in the .lita section.  This is a 16 bit GP
1585              relative relocation.  Sometimes the subsequent reloc is a
1586              LITUSE reloc, which indicates how this reloc is used.
1587              This sometimes permits rewriting the two instructions
1588              referred to by the LITERAL and the LITUSE into different
1589              instructions which do not refer to .lita.  This can save
1590              a memory reference, and permits removing a value from
1591              .lita thus saving GP relative space.
1592
1593              We do not these optimizations.  To do them we would need
1594              to arrange to link the .lita section first, so that by
1595              the time we got here we would know the final values to
1596              use.  This would not be particularly difficult, but it is
1597              not currently implemented.  */
1598
1599           /* I believe that the LITERAL reloc will only apply to a ldq
1600              or ldl instruction, so check my assumption.  */
1601           {
1602             unsigned long insn;
1603
1604             insn = bfd_get_32 (input_bfd,
1605                                contents + r_vaddr - input_section->vma);
1606             BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1607                         || ((insn >> 26) & 0x3f) == 0x28);
1608           }
1609
1610           relocatep = TRUE;
1611           addend = ecoff_data (input_bfd)->gp - gp;
1612           gp_usedp = TRUE;
1613           break;
1614
1615         case ALPHA_R_LITUSE:
1616           /* See ALPHA_R_LITERAL above for the uses of this reloc.  It
1617              does not cause anything to happen, itself.  */
1618           break;
1619
1620         case ALPHA_R_GPDISP:
1621           /* This marks the ldah of an ldah/lda pair which loads the
1622              gp register with the difference of the gp value and the
1623              current location.  The second of the pair is r_symndx
1624              bytes ahead.  It used to be marked with an ALPHA_R_IGNORE
1625              reloc, but OSF/1 3.2 no longer does that.  */
1626           {
1627             unsigned long insn1, insn2;
1628
1629             /* Get the two instructions.  */
1630             insn1 = bfd_get_32 (input_bfd,
1631                                 contents + r_vaddr - input_section->vma);
1632             insn2 = bfd_get_32 (input_bfd,
1633                                 (contents
1634                                  + r_vaddr
1635                                  - input_section->vma
1636                                  + r_symndx));
1637
1638             BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1639             BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1640
1641             /* Get the existing addend.  We must account for the sign
1642                extension done by lda and ldah.  */
1643             addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1644             if (insn1 & 0x8000)
1645               {
1646                 /* This is addend -= 0x100000000 without causing an
1647                    integer overflow on a 32 bit host.  */
1648                 addend -= 0x80000000;
1649                 addend -= 0x80000000;
1650               }
1651             if (insn2 & 0x8000)
1652               addend -= 0x10000;
1653
1654             /* The existing addend includes the difference between the
1655                gp of the input BFD and the address in the input BFD.
1656                We want to change this to the difference between the
1657                final GP and the final address.  */
1658             addend += (gp
1659                        - ecoff_data (input_bfd)->gp
1660                        + input_section->vma
1661                        - (input_section->output_section->vma
1662                           + input_section->output_offset));
1663
1664             /* Change the instructions, accounting for the sign
1665                extension, and write them out.  */
1666             if (addend & 0x8000)
1667               addend += 0x10000;
1668             insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1669             insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1670
1671             bfd_put_32 (input_bfd, (bfd_vma) insn1,
1672                         contents + r_vaddr - input_section->vma);
1673             bfd_put_32 (input_bfd, (bfd_vma) insn2,
1674                         contents + r_vaddr - input_section->vma + r_symndx);
1675
1676             gp_usedp = TRUE;
1677           }
1678           break;
1679
1680         case ALPHA_R_OP_PUSH:
1681         case ALPHA_R_OP_PSUB:
1682         case ALPHA_R_OP_PRSHIFT:
1683           /* Manipulate values on the reloc evaluation stack.  The
1684              r_vaddr field is not an address in input_section, it is
1685              the current value (including any addend) of the object
1686              being used.  */
1687           if (! r_extern)
1688             {
1689               asection *s;
1690
1691               s = symndx_to_section[r_symndx];
1692               if (s == (asection *) NULL)
1693                 abort ();
1694               addend = s->output_section->vma + s->output_offset - s->vma;
1695             }
1696           else
1697             {
1698               struct ecoff_link_hash_entry *h;
1699
1700               h = sym_hashes[r_symndx];
1701               if (h == (struct ecoff_link_hash_entry *) NULL)
1702                 abort ();
1703
1704               if (! info->relocatable)
1705                 {
1706                   if (h->root.type == bfd_link_hash_defined
1707                       || h->root.type == bfd_link_hash_defweak)
1708                     addend = (h->root.u.def.value
1709                               + h->root.u.def.section->output_section->vma
1710                               + h->root.u.def.section->output_offset);
1711                   else
1712                     {
1713                       /* Note that we pass the address as 0, since we
1714                          do not have a meaningful number for the
1715                          location within the section that is being
1716                          relocated.  */
1717                       if (! ((*info->callbacks->undefined_symbol)
1718                              (info, h->root.root.string, input_bfd,
1719                               input_section, (bfd_vma) 0, TRUE)))
1720                         return FALSE;
1721                       addend = 0;
1722                     }
1723                 }
1724               else
1725                 {
1726                   if (h->root.type != bfd_link_hash_defined
1727                       && h->root.type != bfd_link_hash_defweak
1728                       && h->indx == -1)
1729                     {
1730                       /* This symbol is not being written out.  Pass
1731                          the address as 0, as with undefined_symbol,
1732                          above.  */
1733                       if (! ((*info->callbacks->unattached_reloc)
1734                              (info, h->root.root.string, input_bfd,
1735                               input_section, (bfd_vma) 0)))
1736                         return FALSE;
1737                     }
1738
1739                   addend = alpha_convert_external_reloc (output_bfd, info,
1740                                                          input_bfd,
1741                                                          ext_rel, h);
1742                 }
1743             }
1744
1745           addend += r_vaddr;
1746
1747           if (info->relocatable)
1748             {
1749               /* Adjust r_vaddr by the addend.  */
1750               H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr);
1751             }
1752           else
1753             {
1754               switch (r_type)
1755                 {
1756                 case ALPHA_R_OP_PUSH:
1757                   if (tos >= RELOC_STACKSIZE)
1758                     abort ();
1759                   stack[tos++] = addend;
1760                   break;
1761
1762                 case ALPHA_R_OP_PSUB:
1763                   if (tos == 0)
1764                     abort ();
1765                   stack[tos - 1] -= addend;
1766                   break;
1767
1768                 case ALPHA_R_OP_PRSHIFT:
1769                   if (tos == 0)
1770                     abort ();
1771                   stack[tos - 1] >>= addend;
1772                   break;
1773                 }
1774             }
1775
1776           adjust_addrp = FALSE;
1777           break;
1778
1779         case ALPHA_R_OP_STORE:
1780           /* Store a value from the reloc stack into a bitfield.  If
1781              we are generating relocatable output, all we do is
1782              adjust the address of the reloc.  */
1783           if (! info->relocatable)
1784             {
1785               bfd_vma mask;
1786               bfd_vma val;
1787
1788               if (tos == 0)
1789                 abort ();
1790
1791               /* Get the relocation mask.  The separate steps and the
1792                  casts to bfd_vma are attempts to avoid a bug in the
1793                  Alpha OSF 1.3 C compiler.  See reloc.c for more
1794                  details.  */
1795               mask = 1;
1796               mask <<= (bfd_vma) r_size;
1797               mask -= 1;
1798
1799               /* FIXME: I don't know what kind of overflow checking,
1800                  if any, should be done here.  */
1801               val = bfd_get_64 (input_bfd,
1802                                 contents + r_vaddr - input_section->vma);
1803               val &=~ mask << (bfd_vma) r_offset;
1804               val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1805               bfd_put_64 (input_bfd, val,
1806                           contents + r_vaddr - input_section->vma);
1807             }
1808           break;
1809
1810         case ALPHA_R_GPVALUE:
1811           /* I really don't know if this does the right thing.  */
1812           gp = ecoff_data (input_bfd)->gp + r_symndx;
1813           gp_undefined = FALSE;
1814           break;
1815         }
1816
1817       if (relocatep)
1818         {
1819           reloc_howto_type *howto;
1820           struct ecoff_link_hash_entry *h = NULL;
1821           asection *s = NULL;
1822           bfd_vma relocation;
1823           bfd_reloc_status_type r;
1824
1825           /* Perform a relocation.  */
1826
1827           howto = &alpha_howto_table[r_type];
1828
1829           if (r_extern)
1830             {
1831               h = sym_hashes[r_symndx];
1832               /* If h is NULL, that means that there is a reloc
1833                  against an external symbol which we thought was just
1834                  a debugging symbol.  This should not happen.  */
1835               if (h == (struct ecoff_link_hash_entry *) NULL)
1836                 abort ();
1837             }
1838           else
1839             {
1840               if (r_symndx >= NUM_RELOC_SECTIONS)
1841                 s = NULL;
1842               else
1843                 s = symndx_to_section[r_symndx];
1844
1845               if (s == (asection *) NULL)
1846                 abort ();
1847             }
1848
1849           if (info->relocatable)
1850             {
1851               /* We are generating relocatable output, and must
1852                  convert the existing reloc.  */
1853               if (r_extern)
1854                 {
1855                   if (h->root.type != bfd_link_hash_defined
1856                       && h->root.type != bfd_link_hash_defweak
1857                       && h->indx == -1)
1858                     {
1859                       /* This symbol is not being written out.  */
1860                       if (! ((*info->callbacks->unattached_reloc)
1861                              (info, h->root.root.string, input_bfd,
1862                               input_section, r_vaddr - input_section->vma)))
1863                         return FALSE;
1864                     }
1865
1866                   relocation = alpha_convert_external_reloc (output_bfd,
1867                                                              info,
1868                                                              input_bfd,
1869                                                              ext_rel,
1870                                                              h);
1871                 }
1872               else
1873                 {
1874                   /* This is a relocation against a section.  Adjust
1875                      the value by the amount the section moved.  */
1876                   relocation = (s->output_section->vma
1877                                 + s->output_offset
1878                                 - s->vma);
1879                 }
1880
1881               /* If this is PC relative, the existing object file
1882                  appears to already have the reloc worked out.  We
1883                  must subtract out the old value and add in the new
1884                  one.  */
1885               if (howto->pc_relative)
1886                 relocation -= (input_section->output_section->vma
1887                                + input_section->output_offset
1888                                - input_section->vma);
1889
1890               /* Put in any addend.  */
1891               relocation += addend;
1892
1893               /* Adjust the contents.  */
1894               r = _bfd_relocate_contents (howto, input_bfd, relocation,
1895                                           (contents
1896                                            + r_vaddr
1897                                            - input_section->vma));
1898             }
1899           else
1900             {
1901               /* We are producing a final executable.  */
1902               if (r_extern)
1903                 {
1904                   /* This is a reloc against a symbol.  */
1905                   if (h->root.type == bfd_link_hash_defined
1906                       || h->root.type == bfd_link_hash_defweak)
1907                     {
1908                       asection *hsec;
1909
1910                       hsec = h->root.u.def.section;
1911                       relocation = (h->root.u.def.value
1912                                     + hsec->output_section->vma
1913                                     + hsec->output_offset);
1914                     }
1915                   else
1916                     {
1917                       if (! ((*info->callbacks->undefined_symbol)
1918                              (info, h->root.root.string, input_bfd,
1919                               input_section,
1920                               r_vaddr - input_section->vma, TRUE)))
1921                         return FALSE;
1922                       relocation = 0;
1923                     }
1924                 }
1925               else
1926                 {
1927                   /* This is a reloc against a section.  */
1928                   relocation = (s->output_section->vma
1929                                 + s->output_offset
1930                                 - s->vma);
1931
1932                   /* Adjust a PC relative relocation by removing the
1933                      reference to the original source section.  */
1934                   if (howto->pc_relative)
1935                     relocation += input_section->vma;
1936                 }
1937
1938               r = _bfd_final_link_relocate (howto,
1939                                             input_bfd,
1940                                             input_section,
1941                                             contents,
1942                                             r_vaddr - input_section->vma,
1943                                             relocation,
1944                                             addend);
1945             }
1946
1947           if (r != bfd_reloc_ok)
1948             {
1949               switch (r)
1950                 {
1951                 default:
1952                 case bfd_reloc_outofrange:
1953                   abort ();
1954                 case bfd_reloc_overflow:
1955                   {
1956                     const char *name;
1957
1958                     if (r_extern)
1959                       name = sym_hashes[r_symndx]->root.root.string;
1960                     else
1961                       name = bfd_section_name (input_bfd,
1962                                                symndx_to_section[r_symndx]);
1963                     if (! ((*info->callbacks->reloc_overflow)
1964                            (info, NULL, name,
1965                             alpha_howto_table[r_type].name,
1966                             (bfd_vma) 0, input_bfd, input_section,
1967                             r_vaddr - input_section->vma)))
1968                       return FALSE;
1969                   }
1970                   break;
1971                 }
1972             }
1973         }
1974
1975       if (info->relocatable && adjust_addrp)
1976         {
1977           /* Change the address of the relocation.  */
1978           H_PUT_64 (input_bfd,
1979                     (input_section->output_section->vma
1980                      + input_section->output_offset
1981                      - input_section->vma
1982                      + r_vaddr),
1983                     ext_rel->r_vaddr);
1984         }
1985
1986       if (gp_usedp && gp_undefined)
1987         {
1988           if (! ((*info->callbacks->reloc_dangerous)
1989                  (info, _("GP relative relocation used when GP not defined"),
1990                   input_bfd, input_section, r_vaddr - input_section->vma)))
1991             return FALSE;
1992           /* Only give the error once per link.  */
1993           gp = 4;
1994           _bfd_set_gp_value (output_bfd, gp);
1995           gp_undefined = FALSE;
1996         }
1997     }
1998
1999   if (tos != 0)
2000     abort ();
2001
2002   return TRUE;
2003 }
2004 \f
2005 /* Do final adjustments to the filehdr and the aouthdr.  This routine
2006    sets the dynamic bits in the file header.  */
2007
2008 static bfd_boolean
2009 alpha_adjust_headers (abfd, fhdr, ahdr)
2010      bfd *abfd;
2011      struct internal_filehdr *fhdr;
2012      struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED;
2013 {
2014   if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2015     fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2016   else if ((abfd->flags & DYNAMIC) != 0)
2017     fhdr->f_flags |= F_ALPHA_SHARABLE;
2018   return TRUE;
2019 }
2020 \f
2021 /* Archive handling.  In OSF/1 (or Digital Unix) v3.2, Digital
2022    introduced archive packing, in which the elements in an archive are
2023    optionally compressed using a simple dictionary scheme.  We know
2024    how to read such archives, but we don't write them.  */
2025
2026 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2027 #define alpha_ecoff_slurp_extended_name_table \
2028   _bfd_ecoff_slurp_extended_name_table
2029 #define alpha_ecoff_construct_extended_name_table \
2030   _bfd_ecoff_construct_extended_name_table
2031 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2032 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2033 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2034 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2035
2036 /* A compressed file uses this instead of ARFMAG.  */
2037
2038 #define ARFZMAG "Z\012"
2039
2040 /* Read an archive header.  This is like the standard routine, but it
2041    also accepts ARFZMAG.  */
2042
2043 static PTR
2044 alpha_ecoff_read_ar_hdr (abfd)
2045      bfd *abfd;
2046 {
2047   struct areltdata *ret;
2048   struct ar_hdr *h;
2049
2050   ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2051   if (ret == NULL)
2052     return NULL;
2053
2054   h = (struct ar_hdr *) ret->arch_header;
2055   if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2056     {
2057       bfd_byte ab[8];
2058
2059       /* This is a compressed file.  We must set the size correctly.
2060          The size is the eight bytes after the dummy file header.  */
2061       if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0
2062           || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8
2063           || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0)
2064         return NULL;
2065
2066       ret->parsed_size = H_GET_64 (abfd, ab);
2067     }
2068
2069   return (PTR) ret;
2070 }
2071
2072 /* Get an archive element at a specified file position.  This is where
2073    we uncompress the archive element if necessary.  */
2074
2075 static bfd *
2076 alpha_ecoff_get_elt_at_filepos (archive, filepos)
2077      bfd *archive;
2078      file_ptr filepos;
2079 {
2080   bfd *nbfd = NULL;
2081   struct areltdata *tdata;
2082   struct ar_hdr *hdr;
2083   bfd_byte ab[8];
2084   bfd_size_type size;
2085   bfd_byte *buf, *p;
2086   struct bfd_in_memory *bim;
2087
2088   nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2089   if (nbfd == NULL)
2090     goto error_return;
2091
2092   if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2093     {
2094       /* We have already expanded this BFD.  */
2095       return nbfd;
2096     }
2097
2098   tdata = (struct areltdata *) nbfd->arelt_data;
2099   hdr = (struct ar_hdr *) tdata->arch_header;
2100   if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2101     return nbfd;
2102
2103   /* We must uncompress this element.  We do this by copying it into a
2104      memory buffer, and making bfd_bread and bfd_seek use that buffer.
2105      This can use a lot of memory, but it's simpler than getting a
2106      temporary file, making that work with the file descriptor caching
2107      code, and making sure that it is deleted at all appropriate
2108      times.  It can be changed if it ever becomes important.  */
2109
2110   /* The compressed file starts with a dummy ECOFF file header.  */
2111   if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0)
2112     goto error_return;
2113
2114   /* The next eight bytes are the real file size.  */
2115   if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2116     goto error_return;
2117   size = H_GET_64 (nbfd, ab);
2118
2119   if (size == 0)
2120     buf = NULL;
2121   else
2122     {
2123       bfd_size_type left;
2124       bfd_byte dict[4096];
2125       unsigned int h;
2126       bfd_byte b;
2127
2128       buf = (bfd_byte *) bfd_alloc (nbfd, size);
2129       if (buf == NULL)
2130         goto error_return;
2131       p = buf;
2132
2133       left = size;
2134
2135       /* I don't know what the next eight bytes are for.  */
2136       if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2137         goto error_return;
2138
2139       /* This is the uncompression algorithm.  It's a simple
2140          dictionary based scheme in which each character is predicted
2141          by a hash of the previous three characters.  A control byte
2142          indicates whether the character is predicted or whether it
2143          appears in the input stream; each control byte manages the
2144          next eight bytes in the output stream.  */
2145       memset (dict, 0, sizeof dict);
2146       h = 0;
2147       while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1)
2148         {
2149           unsigned int i;
2150
2151           for (i = 0; i < 8; i++, b >>= 1)
2152             {
2153               bfd_byte n;
2154
2155               if ((b & 1) == 0)
2156                 n = dict[h];
2157               else
2158                 {
2159                   if (! bfd_bread (&n, (bfd_size_type) 1, nbfd))
2160                     goto error_return;
2161                   dict[h] = n;
2162                 }
2163
2164               *p++ = n;
2165
2166               --left;
2167               if (left == 0)
2168                 break;
2169
2170               h <<= 4;
2171               h ^= n;
2172               h &= sizeof dict - 1;
2173             }
2174
2175           if (left == 0)
2176             break;
2177         }
2178     }
2179
2180   /* Now the uncompressed file contents are in buf.  */
2181   bim = ((struct bfd_in_memory *)
2182          bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory)));
2183   if (bim == NULL)
2184     goto error_return;
2185   bim->size = size;
2186   bim->buffer = buf;
2187
2188   nbfd->mtime_set = TRUE;
2189   nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2190
2191   nbfd->flags |= BFD_IN_MEMORY;
2192   nbfd->iostream = (PTR) bim;
2193   BFD_ASSERT (! nbfd->cacheable);
2194
2195   return nbfd;
2196
2197  error_return:
2198   if (nbfd != NULL)
2199     bfd_close (nbfd);
2200   return NULL;
2201 }
2202
2203 /* Open the next archived file.  */
2204
2205 static bfd *
2206 alpha_ecoff_openr_next_archived_file (archive, last_file)
2207      bfd *archive;
2208      bfd *last_file;
2209 {
2210   file_ptr filestart;
2211
2212   if (last_file == NULL)
2213     filestart = bfd_ardata (archive)->first_file_filepos;
2214   else
2215     {
2216       struct areltdata *t;
2217       struct ar_hdr *h;
2218       bfd_size_type size;
2219
2220       /* We can't use arelt_size here, because that uses parsed_size,
2221          which is the uncompressed size.  We need the compressed size.  */
2222       t = (struct areltdata *) last_file->arelt_data;
2223       h = (struct ar_hdr *) t->arch_header;
2224       size = strtol (h->ar_size, (char **) NULL, 10);
2225
2226       /* Pad to an even boundary...
2227          Note that last_file->origin can be odd in the case of
2228          BSD-4.4-style element with a long odd size.  */
2229       filestart = last_file->origin + size;
2230       filestart += filestart % 2;
2231     }
2232
2233   return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2234 }
2235
2236 /* Open the archive file given an index into the armap.  */
2237
2238 static bfd *
2239 alpha_ecoff_get_elt_at_index (abfd, index)
2240      bfd *abfd;
2241      symindex index;
2242 {
2243   carsym *entry;
2244
2245   entry = bfd_ardata (abfd)->symdefs + index;
2246   return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2247 }
2248 \f
2249 /* This is the ECOFF backend structure.  The backend field of the
2250    target vector points to this.  */
2251
2252 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2253 {
2254   /* COFF backend structure.  */
2255   {
2256     (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2257     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2258     (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2259     (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2260     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2261     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2262     (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2263     alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2264     alpha_ecoff_swap_scnhdr_out,
2265     FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
2266     alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2267     alpha_ecoff_swap_scnhdr_in, NULL,
2268     alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2269     alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2270     _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2271     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2272     NULL, NULL, NULL
2273   },
2274   /* Supported architecture.  */
2275   bfd_arch_alpha,
2276   /* Initial portion of armap string.  */
2277   "________64",
2278   /* The page boundary used to align sections in a demand-paged
2279      executable file.  E.g., 0x1000.  */
2280   0x2000,
2281   /* TRUE if the .rdata section is part of the text segment, as on the
2282      Alpha.  FALSE if .rdata is part of the data segment, as on the
2283      MIPS.  */
2284   TRUE,
2285   /* Bitsize of constructor entries.  */
2286   64,
2287   /* Reloc to use for constructor entries.  */
2288   &alpha_howto_table[ALPHA_R_REFQUAD],
2289   {
2290     /* Symbol table magic number.  */
2291     magicSym2,
2292     /* Alignment of debugging information.  E.g., 4.  */
2293     8,
2294     /* Sizes of external symbolic information.  */
2295     sizeof (struct hdr_ext),
2296     sizeof (struct dnr_ext),
2297     sizeof (struct pdr_ext),
2298     sizeof (struct sym_ext),
2299     sizeof (struct opt_ext),
2300     sizeof (struct fdr_ext),
2301     sizeof (struct rfd_ext),
2302     sizeof (struct ext_ext),
2303     /* Functions to swap in external symbolic data.  */
2304     ecoff_swap_hdr_in,
2305     ecoff_swap_dnr_in,
2306     ecoff_swap_pdr_in,
2307     ecoff_swap_sym_in,
2308     ecoff_swap_opt_in,
2309     ecoff_swap_fdr_in,
2310     ecoff_swap_rfd_in,
2311     ecoff_swap_ext_in,
2312     _bfd_ecoff_swap_tir_in,
2313     _bfd_ecoff_swap_rndx_in,
2314     /* Functions to swap out external symbolic data.  */
2315     ecoff_swap_hdr_out,
2316     ecoff_swap_dnr_out,
2317     ecoff_swap_pdr_out,
2318     ecoff_swap_sym_out,
2319     ecoff_swap_opt_out,
2320     ecoff_swap_fdr_out,
2321     ecoff_swap_rfd_out,
2322     ecoff_swap_ext_out,
2323     _bfd_ecoff_swap_tir_out,
2324     _bfd_ecoff_swap_rndx_out,
2325     /* Function to read in symbolic data.  */
2326     _bfd_ecoff_slurp_symbolic_info
2327   },
2328   /* External reloc size.  */
2329   RELSZ,
2330   /* Reloc swapping functions.  */
2331   alpha_ecoff_swap_reloc_in,
2332   alpha_ecoff_swap_reloc_out,
2333   /* Backend reloc tweaking.  */
2334   alpha_adjust_reloc_in,
2335   alpha_adjust_reloc_out,
2336   /* Relocate section contents while linking.  */
2337   alpha_relocate_section,
2338   /* Do final adjustments to filehdr and aouthdr.  */
2339   alpha_adjust_headers,
2340   /* Read an element from an archive at a given file position.  */
2341   alpha_ecoff_get_elt_at_filepos
2342 };
2343
2344 /* Looking up a reloc type is Alpha specific.  */
2345 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2346
2347 /* So is getting relocated section contents.  */
2348 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2349   alpha_ecoff_get_relocated_section_contents
2350
2351 /* Handling file windows is generic.  */
2352 #define _bfd_ecoff_get_section_contents_in_window \
2353   _bfd_generic_get_section_contents_in_window
2354
2355 /* Relaxing sections is generic.  */
2356 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2357 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2358 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2359 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2360 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2361 #define _bfd_ecoff_section_already_linked \
2362   _bfd_generic_section_already_linked
2363
2364 const bfd_target ecoffalpha_little_vec =
2365 {
2366   "ecoff-littlealpha",          /* name */
2367   bfd_target_ecoff_flavour,
2368   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2369   BFD_ENDIAN_LITTLE,            /* header byte order is little */
2370
2371   (HAS_RELOC | EXEC_P |         /* object flags */
2372    HAS_LINENO | HAS_DEBUG |
2373    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2374
2375   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2376   0,                            /* leading underscore */
2377   ' ',                          /* ar_pad_char */
2378   15,                           /* ar_max_namelen */
2379   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2380      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2381      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2382   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2383      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2384      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2385
2386   {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2387      _bfd_ecoff_archive_p, _bfd_dummy_target},
2388   {bfd_false, _bfd_ecoff_mkobject,  /* bfd_set_format */
2389      _bfd_generic_mkarchive, bfd_false},
2390   {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2391      _bfd_write_archive_contents, bfd_false},
2392
2393      BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2394      BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2395      BFD_JUMP_TABLE_CORE (_bfd_nocore),
2396      BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2397      BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2398      BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2399      BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2400      BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2401      BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2402
2403   NULL,
2404
2405   (PTR) &alpha_ecoff_backend_data
2406 };