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