bfd/coff-alpha.c

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