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