bfd/coff-alpha.c

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