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