bfd/coff-alpha.c

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