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