bfd/coff-alpha.c

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