bfd/elf64-alpha.c

   1 /* Alpha specific support for 64-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4    Contributed by Richard Henderson <rth@tamu.edu>.
   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 /* We need a published ABI spec for this.  Until one comes out, don't
  23    assume this'll remain unchanged forever.  */
  24
  25 #include "bfd.h"
  26 #include "sysdep.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29
  30 #include "elf/alpha.h"
  31
  32 #define ALPHAECOFF
  33
  34 #define NO_COFF_RELOCS
  35 #define NO_COFF_SYMBOLS
  36 #define NO_COFF_LINENOS
  37
  38 /* Get the ECOFF swapping routines.  Needed for the debug information.  */
  39 #include "coff/internal.h"
  40 #include "coff/sym.h"
  41 #include "coff/symconst.h"
  42 #include "coff/ecoff.h"
  43 #include "coff/alpha.h"
  44 #include "aout/ar.h"
  45 #include "libcoff.h"
  46 #include "libecoff.h"
  47 #define ECOFF_64
  48 #include "ecoffswap.h"
  49
  50 static int alpha_elf_dynamic_symbol_p
  51   PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
  52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
  53   PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
  55   PARAMS((bfd *));
  56
  57 static bfd_reloc_status_type elf64_alpha_reloc_nil
  58   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  59 static bfd_reloc_status_type elf64_alpha_reloc_bad
  60   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
  62   PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
  63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
  64   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  65
  66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
  67   PARAMS((bfd *, bfd_reloc_code_real_type));
  68 static void elf64_alpha_info_to_howto
  69   PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
  70
  71 static boolean elf64_alpha_mkobject
  72   PARAMS((bfd *));
  73 static boolean elf64_alpha_object_p
  74   PARAMS((bfd *));
  75 static boolean elf64_alpha_section_from_shdr
  76   PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
  77 static boolean elf64_alpha_fake_sections
  78   PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
  79 static boolean elf64_alpha_create_got_section
  80   PARAMS((bfd *, struct bfd_link_info *));
  81 static boolean elf64_alpha_create_dynamic_sections
  82   PARAMS((bfd *, struct bfd_link_info *));
  83
  84 static boolean elf64_alpha_read_ecoff_info
  85   PARAMS((bfd *, asection *, struct ecoff_debug_info *));
  86 static boolean elf64_alpha_is_local_label_name
  87   PARAMS((bfd *, const char *));
  88 static boolean elf64_alpha_find_nearest_line
  89   PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
  90           const char **, unsigned int *));
  91
  92 #if defined(__STDC__) || defined(ALMOST_STDC)
  93 struct alpha_elf_link_hash_entry;
  94 #endif
  95
  96 static boolean elf64_alpha_output_extsym
  97   PARAMS((struct alpha_elf_link_hash_entry *, PTR));
  98
  99 static boolean elf64_alpha_can_merge_gots
 100   PARAMS((bfd *, bfd *));
 101 static void elf64_alpha_merge_gots
 102   PARAMS((bfd *, bfd *));
 103 static boolean elf64_alpha_calc_got_offsets_for_symbol
 104   PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
 105 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
 106 static boolean elf64_alpha_size_got_sections
 107   PARAMS ((bfd *, struct bfd_link_info *));
 108 static boolean elf64_alpha_always_size_sections
 109   PARAMS ((bfd *, struct bfd_link_info *));
 110 static boolean elf64_alpha_calc_dynrel_sizes
 111   PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
 112 static boolean elf64_alpha_add_symbol_hook
 113   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
 114            const char **, flagword *, asection **, bfd_vma *));
 115 static boolean elf64_alpha_check_relocs
 116   PARAMS((bfd *, struct bfd_link_info *, asection *sec,
 117           const Elf_Internal_Rela *));
 118 static boolean elf64_alpha_adjust_dynamic_symbol
 119   PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
 120 static boolean elf64_alpha_size_dynamic_sections
 121   PARAMS((bfd *, struct bfd_link_info *));
 122 static boolean elf64_alpha_relocate_section
 123   PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 124           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
 125 static boolean elf64_alpha_finish_dynamic_symbol
 126   PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
 127           Elf_Internal_Sym *));
 128 static boolean elf64_alpha_finish_dynamic_sections
 129   PARAMS((bfd *, struct bfd_link_info *));
 130 static boolean elf64_alpha_final_link
 131   PARAMS((bfd *, struct bfd_link_info *));
 132 static boolean elf64_alpha_merge_ind_symbols
 133   PARAMS((struct alpha_elf_link_hash_entry *, PTR));
 134 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
 135   PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
 136 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
 137   PARAMS ((int));
 138 \f
 139 struct alpha_elf_link_hash_entry
 140 {
 141   struct elf_link_hash_entry root;
 142
 143   /* External symbol information.  */
 144   EXTR esym;
 145
 146   /* Cumulative flags for all the .got entries.  */
 147   int flags;
 148
 149   /* Contexts (LITUSE) in which a literal was referenced.  */
 150 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
 151 #define ALPHA_ELF_LINK_HASH_LU_MEM  0x02
 152 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
 153 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
 154
 155   /* Used to implement multiple .got subsections.  */
 156   struct alpha_elf_got_entry
 157   {
 158     struct alpha_elf_got_entry *next;
 159
 160     /* which .got subsection?  */
 161     bfd *gotobj;
 162
 163     /* the addend in effect for this entry.  */
 164     bfd_signed_vma addend;
 165
 166     /* the .got offset for this entry.  */
 167     int got_offset;
 168
 169     int flags;
 170
 171     /* An additional flag.  */
 172 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
 173
 174     int use_count;
 175   } *got_entries;
 176
 177   /* used to count non-got, non-plt relocations for delayed sizing
 178      of relocation sections.  */
 179   struct alpha_elf_reloc_entry
 180   {
 181     struct alpha_elf_reloc_entry *next;
 182
 183     /* which .reloc section? */
 184     asection *srel;
 185
 186     /* what kind of relocation? */
 187     unsigned int rtype;
 188
 189     /* is this against read-only section? */
 190     unsigned int reltext : 1;
 191
 192     /* how many did we find?  */
 193     unsigned long count;
 194   } *reloc_entries;
 195 };
 196
 197 /* Alpha ELF linker hash table.  */
 198
 199 struct alpha_elf_link_hash_table
 200 {
 201   struct elf_link_hash_table root;
 202
 203   /* The head of a list of .got subsections linked through
 204      alpha_elf_tdata(abfd)->got_link_next.  */
 205   bfd *got_list;
 206 };
 207
 208 /* Look up an entry in a Alpha ELF linker hash table.  */
 209
 210 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
 211   ((struct alpha_elf_link_hash_entry *)                                 \
 212    elf_link_hash_lookup (&(table)->root, (string), (create),            \
 213                          (copy), (follow)))
 214
 215 /* Traverse a Alpha ELF linker hash table.  */
 216
 217 #define alpha_elf_link_hash_traverse(table, func, info)                 \
 218   (elf_link_hash_traverse                                               \
 219    (&(table)->root,                                                     \
 220     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
 221     (info)))
 222
 223 /* Get the Alpha ELF linker hash table from a link_info structure.  */
 224
 225 #define alpha_elf_hash_table(p) \
 226   ((struct alpha_elf_link_hash_table *) ((p)->hash))
 227
 228 /* Get the object's symbols as our own entry type.  */
 229
 230 #define alpha_elf_sym_hashes(abfd) \
 231   ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
 232
 233 /* Should we do dynamic things to this symbol?  */
 234
 235 static int
 236 alpha_elf_dynamic_symbol_p (h, info)
 237      struct elf_link_hash_entry *h;
 238      struct bfd_link_info *info;
 239 {
 240   if (h == NULL)
 241     return false;
 242
 243   while (h->root.type == bfd_link_hash_indirect
 244          || h->root.type == bfd_link_hash_warning)
 245     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 246
 247   if (h->dynindx == -1)
 248     return false;
 249
 250   if (h->root.type == bfd_link_hash_undefweak
 251       || h->root.type == bfd_link_hash_defweak)
 252     return true;
 253
 254   switch (ELF_ST_VISIBILITY (h->other))
 255     {
 256     case STV_DEFAULT:
 257       break;
 258     case STV_HIDDEN:
 259     case STV_INTERNAL:
 260       return false;
 261     case STV_PROTECTED:
 262       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
 263         return false;
 264       break;
 265     }
 266
 267   if ((info->shared && !info->symbolic)
 268       || ((h->elf_link_hash_flags
 269            & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
 270           == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
 271     return true;
 272
 273   return false;
 274 }
 275
 276 /* Create an entry in a Alpha ELF linker hash table.  */
 277
 278 static struct bfd_hash_entry *
 279 elf64_alpha_link_hash_newfunc (entry, table, string)
 280      struct bfd_hash_entry *entry;
 281      struct bfd_hash_table *table;
 282      const char *string;
 283 {
 284   struct alpha_elf_link_hash_entry *ret =
 285     (struct alpha_elf_link_hash_entry *) entry;
 286
 287   /* Allocate the structure if it has not already been allocated by a
 288      subclass.  */
 289   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
 290     ret = ((struct alpha_elf_link_hash_entry *)
 291            bfd_hash_allocate (table,
 292                               sizeof (struct alpha_elf_link_hash_entry)));
 293   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
 294     return (struct bfd_hash_entry *) ret;
 295
 296   /* Call the allocation method of the superclass.  */
 297   ret = ((struct alpha_elf_link_hash_entry *)
 298          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 299                                      table, string));
 300   if (ret != (struct alpha_elf_link_hash_entry *) NULL)
 301     {
 302       /* Set local fields.  */
 303       memset (&ret->esym, 0, sizeof (EXTR));
 304       /* We use -2 as a marker to indicate that the information has
 305          not been set.  -1 means there is no associated ifd.  */
 306       ret->esym.ifd = -2;
 307       ret->flags = 0;
 308       ret->got_entries = NULL;
 309       ret->reloc_entries = NULL;
 310     }
 311
 312   return (struct bfd_hash_entry *) ret;
 313 }
 314
 315 /* Create a Alpha ELF linker hash table.  */
 316
 317 static struct bfd_link_hash_table *
 318 elf64_alpha_bfd_link_hash_table_create (abfd)
 319      bfd *abfd;
 320 {
 321   struct alpha_elf_link_hash_table *ret;
 322
 323   ret = ((struct alpha_elf_link_hash_table *)
 324          bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
 325   if (ret == (struct alpha_elf_link_hash_table *) NULL)
 326     return NULL;
 327
 328   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
 329                                        elf64_alpha_link_hash_newfunc))
 330     {
 331       bfd_release (abfd, ret);
 332       return NULL;
 333     }
 334
 335   return &ret->root.root;
 336 }
 337 \f
 338 /* We have some private fields hanging off of the elf_tdata structure.  */
 339
 340 struct alpha_elf_obj_tdata
 341 {
 342   struct elf_obj_tdata root;
 343
 344   /* For every input file, these are the got entries for that object's
 345      local symbols.  */
 346   struct alpha_elf_got_entry ** local_got_entries;
 347
 348   /* For every input file, this is the object that owns the got that
 349      this input file uses.  */
 350   bfd *gotobj;
 351
 352   /* For every got, this is a linked list through the objects using this got */
 353   bfd *in_got_link_next;
 354
 355   /* For every got, this is a link to the next got subsegment.  */
 356   bfd *got_link_next;
 357
 358   /* For every got, this is the section.  */
 359   asection *got;
 360
 361   /* For every got, this is it's total number of *entries*.  */
 362   int total_got_entries;
 363
 364   /* For every got, this is the sum of the number of *entries* required
 365      to hold all of the member object's local got.  */
 366   int n_local_got_entries;
 367 };
 368
 369 #define alpha_elf_tdata(abfd) \
 370   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
 371
 372 static boolean
 373 elf64_alpha_mkobject (abfd)
 374      bfd *abfd;
 375 {
 376   abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
 377   if (abfd->tdata.any == NULL)
 378     return false;
 379   return true;
 380 }
 381
 382 static boolean
 383 elf64_alpha_object_p (abfd)
 384      bfd *abfd;
 385 {
 386   /* Allocate our special target data.  */
 387   struct alpha_elf_obj_tdata *new_tdata;
 388   new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
 389   if (new_tdata == NULL)
 390     return false;
 391   new_tdata->root = *abfd->tdata.elf_obj_data;
 392   abfd->tdata.any = new_tdata;
 393
 394   /* Set the right machine number for an Alpha ELF file.  */
 395   return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
 396 }
 397 \f
 398 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 399    from smaller values.  Start with zero, widen, *then* decrement.  */
 400 #define MINUS_ONE       (((bfd_vma)0) - 1)
 401
 402 #define SKIP_HOWTO(N) \
 403   HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
 404
 405 static reloc_howto_type elf64_alpha_howto_table[] =
 406 {
 407   HOWTO (R_ALPHA_NONE,          /* type */
 408          0,                     /* rightshift */
 409          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          8,                     /* bitsize */
 411          true,                  /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_dont, /* complain_on_overflow */
 414          elf64_alpha_reloc_nil, /* special_function */
 415          "NONE",                /* name */
 416          false,                 /* partial_inplace */
 417          0,                     /* src_mask */
 418          0,                     /* dst_mask */
 419          true),                 /* pcrel_offset */
 420
 421   /* A 32 bit reference to a symbol.  */
 422   HOWTO (R_ALPHA_REFLONG,       /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          32,                    /* bitsize */
 426          false,                 /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_bitfield, /* complain_on_overflow */
 429          0,                     /* special_function */
 430          "REFLONG",             /* name */
 431          false,                 /* partial_inplace */
 432          0xffffffff,            /* src_mask */
 433          0xffffffff,            /* dst_mask */
 434          false),                /* pcrel_offset */
 435
 436   /* A 64 bit reference to a symbol.  */
 437   HOWTO (R_ALPHA_REFQUAD,       /* type */
 438          0,                     /* rightshift */
 439          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 440          64,                    /* bitsize */
 441          false,                 /* pc_relative */
 442          0,                     /* bitpos */
 443          complain_overflow_bitfield, /* complain_on_overflow */
 444          0,                     /* special_function */
 445          "REFQUAD",             /* name */
 446          false,                 /* partial_inplace */
 447          MINUS_ONE,             /* src_mask */
 448          MINUS_ONE,             /* dst_mask */
 449          false),                /* pcrel_offset */
 450
 451   /* A 32 bit GP relative offset.  This is just like REFLONG except
 452      that when the value is used the value of the gp register will be
 453      added in.  */
 454   HOWTO (R_ALPHA_GPREL32,       /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          32,                    /* bitsize */
 458          false,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_bitfield, /* complain_on_overflow */
 461          0,                     /* special_function */
 462          "GPREL32",             /* name */
 463          false,                 /* partial_inplace */
 464          0xffffffff,            /* src_mask */
 465          0xffffffff,            /* dst_mask */
 466          false),                /* pcrel_offset */
 467
 468   /* Used for an instruction that refers to memory off the GP register.  */
 469   HOWTO (R_ALPHA_LITERAL,       /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          false,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_signed, /* complain_on_overflow */
 476          0,                     /* special_function */
 477          "ELF_LITERAL",         /* name */
 478          false,                 /* partial_inplace */
 479          0xffff,                /* src_mask */
 480          0xffff,                /* dst_mask */
 481          false),                /* pcrel_offset */
 482
 483   /* This reloc only appears immediately following an ELF_LITERAL reloc.
 484      It identifies a use of the literal.  The symbol index is special:
 485      1 means the literal address is in the base register of a memory
 486      format instruction; 2 means the literal address is in the byte
 487      offset register of a byte-manipulation instruction; 3 means the
 488      literal address is in the target register of a jsr instruction.
 489      This does not actually do any relocation.  */
 490   HOWTO (R_ALPHA_LITUSE,        /* type */
 491          0,                     /* rightshift */
 492          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 493          32,                    /* bitsize */
 494          false,                 /* pc_relative */
 495          0,                     /* bitpos */
 496          complain_overflow_dont, /* complain_on_overflow */
 497          elf64_alpha_reloc_nil, /* special_function */
 498          "LITUSE",              /* name */
 499          false,                 /* partial_inplace */
 500          0,                     /* src_mask */
 501          0,                     /* dst_mask */
 502          false),                /* pcrel_offset */
 503
 504   /* Load the gp register.  This is always used for a ldah instruction
 505      which loads the upper 16 bits of the gp register.  The symbol
 506      index of the GPDISP instruction is an offset in bytes to the lda
 507      instruction that loads the lower 16 bits.  The value to use for
 508      the relocation is the difference between the GP value and the
 509      current location; the load will always be done against a register
 510      holding the current address.
 511
 512      NOTE: Unlike ECOFF, partial in-place relocation is not done.  If
 513      any offset is present in the instructions, it is an offset from
 514      the register to the ldah instruction.  This lets us avoid any
 515      stupid hackery like inventing a gp value to do partial relocation
 516      against.  Also unlike ECOFF, we do the whole relocation off of
 517      the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair.  An odd,
 518      space consuming bit, that, since all the information was present
 519      in the GPDISP_HI16 reloc.  */
 520   HOWTO (R_ALPHA_GPDISP,        /* type */
 521          16,                    /* rightshift */
 522          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 523          16,                    /* bitsize */
 524          false,                 /* pc_relative */
 525          0,                     /* bitpos */
 526          complain_overflow_dont, /* complain_on_overflow */
 527          elf64_alpha_reloc_gpdisp, /* special_function */
 528          "GPDISP",              /* name */
 529          false,                 /* partial_inplace */
 530          0xffff,                /* src_mask */
 531          0xffff,                /* dst_mask */
 532          true),                 /* pcrel_offset */
 533
 534   /* A 21 bit branch.  */
 535   HOWTO (R_ALPHA_BRADDR,        /* type */
 536          2,                     /* rightshift */
 537          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 538          21,                    /* bitsize */
 539          true,                  /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_signed, /* complain_on_overflow */
 542          0,                     /* special_function */
 543          "BRADDR",              /* name */
 544          false,                 /* partial_inplace */
 545          0x1fffff,              /* src_mask */
 546          0x1fffff,              /* dst_mask */
 547          true),                 /* pcrel_offset */
 548
 549   /* A hint for a jump to a register.  */
 550   HOWTO (R_ALPHA_HINT,          /* type */
 551          2,                     /* rightshift */
 552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 553          14,                    /* bitsize */
 554          true,                  /* pc_relative */
 555          0,                     /* bitpos */
 556          complain_overflow_dont, /* complain_on_overflow */
 557          0,                     /* special_function */
 558          "HINT",                /* name */
 559          false,                 /* partial_inplace */
 560          0x3fff,                /* src_mask */
 561          0x3fff,                /* dst_mask */
 562          true),                 /* pcrel_offset */
 563
 564   /* 16 bit PC relative offset.  */
 565   HOWTO (R_ALPHA_SREL16,        /* type */
 566          0,                     /* rightshift */
 567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 568          16,                    /* bitsize */
 569          true,                  /* pc_relative */
 570          0,                     /* bitpos */
 571          complain_overflow_signed, /* complain_on_overflow */
 572          0,                     /* special_function */
 573          "SREL16",              /* name */
 574          false,                 /* partial_inplace */
 575          0xffff,                /* src_mask */
 576          0xffff,                /* dst_mask */
 577          true),                 /* pcrel_offset */
 578
 579   /* 32 bit PC relative offset.  */
 580   HOWTO (R_ALPHA_SREL32,        /* type */
 581          0,                     /* rightshift */
 582          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          32,                    /* bitsize */
 584          true,                  /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_signed, /* complain_on_overflow */
 587          0,                     /* special_function */
 588          "SREL32",              /* name */
 589          false,                 /* partial_inplace */
 590          0xffffffff,            /* src_mask */
 591          0xffffffff,            /* dst_mask */
 592          true),                 /* pcrel_offset */
 593
 594   /* A 64 bit PC relative offset.  */
 595   HOWTO (R_ALPHA_SREL64,        /* type */
 596          0,                     /* rightshift */
 597          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          64,                    /* bitsize */
 599          true,                  /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_signed, /* complain_on_overflow */
 602          0,                     /* special_function */
 603          "SREL64",              /* name */
 604          false,                 /* partial_inplace */
 605          MINUS_ONE,             /* src_mask */
 606          MINUS_ONE,             /* dst_mask */
 607          true),                 /* pcrel_offset */
 608
 609   /* Skip 12 - 16; deprecated ECOFF relocs.  */
 610   SKIP_HOWTO (12),
 611   SKIP_HOWTO (13),
 612   SKIP_HOWTO (14),
 613   SKIP_HOWTO (15),
 614   SKIP_HOWTO (16),
 615
 616   /* The high 16 bits of the displacement from GP to the target.  */
 617   HOWTO (R_ALPHA_GPRELHIGH,
 618          0,                     /* rightshift */
 619          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 620          16,                    /* bitsize */
 621          false,                 /* pc_relative */
 622          0,                     /* bitpos */
 623          complain_overflow_signed, /* complain_on_overflow */
 624          0,                     /* special_function */
 625          "GPRELHIGH",           /* name */
 626          false,                 /* partial_inplace */
 627          0xffff,                /* src_mask */
 628          0xffff,                /* dst_mask */
 629          false),                /* pcrel_offset */
 630
 631   /* The low 16 bits of the displacement from GP to the target.  */
 632   HOWTO (R_ALPHA_GPRELLOW,
 633          0,                     /* rightshift */
 634          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 635          16,                    /* bitsize */
 636          false,                 /* pc_relative */
 637          0,                     /* bitpos */
 638          complain_overflow_dont, /* complain_on_overflow */
 639          0,                     /* special_function */
 640          "GPRELLOW",            /* name */
 641          false,                 /* partial_inplace */
 642          0xffff,                /* src_mask */
 643          0xffff,                /* dst_mask */
 644          false),                /* pcrel_offset */
 645
 646   /* A 16-bit displacement from the GP to the target.  */
 647   HOWTO (R_ALPHA_GPREL16,
 648          0,                     /* rightshift */
 649          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 650          16,                    /* bitsize */
 651          false,                 /* pc_relative */
 652          0,                     /* bitpos */
 653          complain_overflow_signed, /* complain_on_overflow */
 654          0,                     /* special_function */
 655          "GPREL16",             /* name */
 656          false,                 /* partial_inplace */
 657          0xffff,                /* src_mask */
 658          0xffff,                /* dst_mask */
 659          false),                /* pcrel_offset */
 660
 661   /* Skip 20 - 23; deprecated ECOFF relocs.  */
 662   SKIP_HOWTO (20),
 663   SKIP_HOWTO (21),
 664   SKIP_HOWTO (22),
 665   SKIP_HOWTO (23),
 666
 667   /* Misc ELF relocations.  */
 668
 669   /* A dynamic relocation to copy the target into our .dynbss section.  */
 670   /* Not generated, as all Alpha objects use PIC, so it is not needed.  It
 671      is present because every other ELF has one, but should not be used
 672      because .dynbss is an ugly thing.  */
 673   HOWTO (R_ALPHA_COPY,
 674          0,
 675          0,
 676          0,
 677          false,
 678          0,
 679          complain_overflow_dont,
 680          bfd_elf_generic_reloc,
 681          "COPY",
 682          false,
 683          0,
 684          0,
 685          true),
 686
 687   /* A dynamic relocation for a .got entry.  */
 688   HOWTO (R_ALPHA_GLOB_DAT,
 689          0,
 690          0,
 691          0,
 692          false,
 693          0,
 694          complain_overflow_dont,
 695          bfd_elf_generic_reloc,
 696          "GLOB_DAT",
 697          false,
 698          0,
 699          0,
 700          true),
 701
 702   /* A dynamic relocation for a .plt entry.  */
 703   HOWTO (R_ALPHA_JMP_SLOT,
 704          0,
 705          0,
 706          0,
 707          false,
 708          0,
 709          complain_overflow_dont,
 710          bfd_elf_generic_reloc,
 711          "JMP_SLOT",
 712          false,
 713          0,
 714          0,
 715          true),
 716
 717   /* A dynamic relocation to add the base of the DSO to a 64-bit field.  */
 718   HOWTO (R_ALPHA_RELATIVE,
 719          0,
 720          0,
 721          0,
 722          false,
 723          0,
 724          complain_overflow_dont,
 725          bfd_elf_generic_reloc,
 726          "RELATIVE",
 727          false,
 728          0,
 729          0,
 730          true)
 731 };
 732
 733 /* A relocation function which doesn't do anything.  */
 734
 735 static bfd_reloc_status_type
 736 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
 737      bfd *abfd ATTRIBUTE_UNUSED;
 738      arelent *reloc;
 739      asymbol *sym ATTRIBUTE_UNUSED;
 740      PTR data ATTRIBUTE_UNUSED;
 741      asection *sec;
 742      bfd *output_bfd;
 743      char **error_message ATTRIBUTE_UNUSED;
 744 {
 745   if (output_bfd)
 746     reloc->address += sec->output_offset;
 747   return bfd_reloc_ok;
 748 }
 749
 750 /* A relocation function used for an unsupported reloc.  */
 751
 752 static bfd_reloc_status_type
 753 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
 754      bfd *abfd ATTRIBUTE_UNUSED;
 755      arelent *reloc;
 756      asymbol *sym ATTRIBUTE_UNUSED;
 757      PTR data ATTRIBUTE_UNUSED;
 758      asection *sec;
 759      bfd *output_bfd;
 760      char **error_message ATTRIBUTE_UNUSED;
 761 {
 762   if (output_bfd)
 763     reloc->address += sec->output_offset;
 764   return bfd_reloc_notsupported;
 765 }
 766
 767 /* Do the work of the GPDISP relocation.  */
 768
 769 static bfd_reloc_status_type
 770 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
 771      bfd *abfd;
 772      bfd_vma gpdisp;
 773      bfd_byte *p_ldah;
 774      bfd_byte *p_lda;
 775 {
 776   bfd_reloc_status_type ret = bfd_reloc_ok;
 777   bfd_vma addend;
 778   unsigned long i_ldah, i_lda;
 779
 780   i_ldah = bfd_get_32 (abfd, p_ldah);
 781   i_lda = bfd_get_32 (abfd, p_lda);
 782
 783   /* Complain if the instructions are not correct.  */
 784   if (((i_ldah >> 26) & 0x3f) != 0x09
 785       || ((i_lda >> 26) & 0x3f) != 0x08)
 786     ret = bfd_reloc_dangerous;
 787
 788   /* Extract the user-supplied offset, mirroring the sign extensions
 789      that the instructions perform.  */
 790   addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
 791   addend = (addend ^ 0x80008000) - 0x80008000;
 792
 793   gpdisp += addend;
 794
 795   if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
 796       || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
 797     ret = bfd_reloc_overflow;
 798
 799   /* compensate for the sign extension again.  */
 800   i_ldah = ((i_ldah & 0xffff0000)
 801             | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
 802   i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
 803
 804   bfd_put_32 (abfd, i_ldah, p_ldah);
 805   bfd_put_32 (abfd, i_lda, p_lda);
 806
 807   return ret;
 808 }
 809
 810 /* The special function for the GPDISP reloc.  */
 811
 812 static bfd_reloc_status_type
 813 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
 814                           output_bfd, err_msg)
 815      bfd *abfd;
 816      arelent *reloc_entry;
 817      asymbol *sym ATTRIBUTE_UNUSED;
 818      PTR data;
 819      asection *input_section;
 820      bfd *output_bfd;
 821      char **err_msg;
 822 {
 823   bfd_reloc_status_type ret;
 824   bfd_vma gp, relocation;
 825   bfd_byte *p_ldah, *p_lda;
 826
 827   /* Don't do anything if we're not doing a final link.  */
 828   if (output_bfd)
 829     {
 830       reloc_entry->address += input_section->output_offset;
 831       return bfd_reloc_ok;
 832     }
 833
 834   if (reloc_entry->address > input_section->_cooked_size ||
 835       reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
 836     return bfd_reloc_outofrange;
 837
 838   /* The gp used in the portion of the output object to which this
 839      input object belongs is cached on the input bfd.  */
 840   gp = _bfd_get_gp_value (abfd);
 841
 842   relocation = (input_section->output_section->vma
 843                 + input_section->output_offset
 844                 + reloc_entry->address);
 845
 846   p_ldah = (bfd_byte *) data + reloc_entry->address;
 847   p_lda = p_ldah + reloc_entry->addend;
 848
 849   ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
 850
 851   /* Complain if the instructions are not correct.  */
 852   if (ret == bfd_reloc_dangerous)
 853     *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
 854
 855   return ret;
 856 }
 857
 858 /* A mapping from BFD reloc types to Alpha ELF reloc types.  */
 859
 860 struct elf_reloc_map
 861 {
 862   bfd_reloc_code_real_type bfd_reloc_val;
 863   int elf_reloc_val;
 864 };
 865
 866 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
 867 {
 868   {BFD_RELOC_NONE,                      R_ALPHA_NONE},
 869   {BFD_RELOC_32,                        R_ALPHA_REFLONG},
 870   {BFD_RELOC_64,                        R_ALPHA_REFQUAD},
 871   {BFD_RELOC_CTOR,                      R_ALPHA_REFQUAD},
 872   {BFD_RELOC_GPREL32,                   R_ALPHA_GPREL32},
 873   {BFD_RELOC_ALPHA_ELF_LITERAL,         R_ALPHA_LITERAL},
 874   {BFD_RELOC_ALPHA_LITUSE,              R_ALPHA_LITUSE},
 875   {BFD_RELOC_ALPHA_GPDISP,              R_ALPHA_GPDISP},
 876   {BFD_RELOC_23_PCREL_S2,               R_ALPHA_BRADDR},
 877   {BFD_RELOC_ALPHA_HINT,                R_ALPHA_HINT},
 878   {BFD_RELOC_16_PCREL,                  R_ALPHA_SREL16},
 879   {BFD_RELOC_32_PCREL,                  R_ALPHA_SREL32},
 880   {BFD_RELOC_64_PCREL,                  R_ALPHA_SREL64},
 881   {BFD_RELOC_ALPHA_GPREL_HI16,          R_ALPHA_GPRELHIGH},
 882   {BFD_RELOC_ALPHA_GPREL_LO16,          R_ALPHA_GPRELLOW},
 883   {BFD_RELOC_GPREL16,                   R_ALPHA_GPREL16},
 884 };
 885
 886 /* Given a BFD reloc type, return a HOWTO structure.  */
 887
 888 static reloc_howto_type *
 889 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
 890      bfd *abfd ATTRIBUTE_UNUSED;
 891      bfd_reloc_code_real_type code;
 892 {
 893   const struct elf_reloc_map *i, *e;
 894   i = e = elf64_alpha_reloc_map;
 895   e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
 896   for (; i != e; ++i)
 897     {
 898       if (i->bfd_reloc_val == code)
 899         return &elf64_alpha_howto_table[i->elf_reloc_val];
 900     }
 901   return 0;
 902 }
 903
 904 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
 905
 906 static void
 907 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
 908      bfd *abfd ATTRIBUTE_UNUSED;
 909      arelent *cache_ptr;
 910      Elf64_Internal_Rela *dst;
 911 {
 912   unsigned r_type;
 913
 914   r_type = ELF64_R_TYPE(dst->r_info);
 915   BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
 916   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
 917 }
 918 \f
 919 /* These functions do relaxation for Alpha ELF.
 920
 921    Currently I'm only handling what I can do with existing compiler
 922    and assembler support, which means no instructions are removed,
 923    though some may be nopped.  At this time GCC does not emit enough
 924    information to do all of the relaxing that is possible.  It will
 925    take some not small amount of work for that to happen.
 926
 927    There are a couple of interesting papers that I once read on this
 928    subject, that I cannot find references to at the moment, that
 929    related to Alpha in particular.  They are by David Wall, then of
 930    DEC WRL.  */
 931
 932 #define OP_LDA          0x08
 933 #define OP_LDAH         0x09
 934 #define INSN_JSR        0x68004000
 935 #define INSN_JSR_MASK   0xfc00c000
 936 #define OP_LDQ          0x29
 937 #define OP_BR           0x30
 938 #define OP_BSR          0x34
 939 #define INSN_UNOP       0x2fe00000
 940
 941 struct alpha_relax_info
 942 {
 943   bfd *abfd;
 944   asection *sec;
 945   bfd_byte *contents;
 946   Elf_Internal_Rela *relocs, *relend;
 947   struct bfd_link_info *link_info;
 948   boolean changed_contents;
 949   boolean changed_relocs;
 950   bfd_vma gp;
 951   bfd *gotobj;
 952   asection *tsec;
 953   struct alpha_elf_link_hash_entry *h;
 954   struct alpha_elf_got_entry *gotent;
 955   unsigned char other;
 956 };
 957
 958 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
 959   PARAMS((struct alpha_relax_info *info, bfd_vma symval,
 960           Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
 961
 962 static boolean elf64_alpha_relax_without_lituse
 963   PARAMS((struct alpha_relax_info *info, bfd_vma symval,
 964           Elf_Internal_Rela *irel));
 965
 966 static bfd_vma elf64_alpha_relax_opt_call
 967   PARAMS((struct alpha_relax_info *info, bfd_vma symval));
 968
 969 static boolean elf64_alpha_relax_section
 970   PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
 971           boolean *again));
 972
 973 static Elf_Internal_Rela *
 974 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
 975      Elf_Internal_Rela *rel, *relend;
 976      bfd_vma offset;
 977      int type;
 978 {
 979   while (rel < relend)
 980     {
 981       if (rel->r_offset == offset
 982           && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
 983         return rel;
 984       ++rel;
 985     }
 986   return NULL;
 987 }
 988
 989 static Elf_Internal_Rela *
 990 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
 991      struct alpha_relax_info *info;
 992      bfd_vma symval;
 993      Elf_Internal_Rela *irel, *irelend;
 994 {
 995   Elf_Internal_Rela *urel;
 996   int flags, count, i;
 997   bfd_signed_vma disp;
 998   boolean fits16;
 999   boolean fits32;
1000   boolean lit_reused = false;
1001   boolean all_optimized = true;
1002   unsigned int lit_insn;
1003
1004   lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1005   if (lit_insn >> 26 != OP_LDQ)
1006     {
1007       ((*_bfd_error_handler)
1008        ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1009         bfd_get_filename (info->abfd), info->sec->name,
1010         (unsigned long)irel->r_offset));
1011       return irel;
1012     }
1013
1014   /* Summarize how this particular LITERAL is used.  */
1015   for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1016     {
1017       if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1018         break;
1019       if (urel->r_addend >= 0 && urel->r_addend <= 3)
1020         flags |= 1 << urel->r_addend;
1021     }
1022
1023   /* A little preparation for the loop...  */
1024   disp = symval - info->gp;
1025
1026   for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1027     {
1028       unsigned int insn;
1029       int insn_disp;
1030       bfd_signed_vma xdisp;
1031
1032       insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1033
1034       switch (urel->r_addend)
1035         {
1036         default: /* 0 = ADDRESS FORMAT */
1037           /* This type is really just a placeholder to note that all
1038              uses cannot be optimized, but to still allow some.  */
1039           all_optimized = false;
1040           break;
1041
1042         case 1: /* MEM FORMAT */
1043           /* We can always optimize 16-bit displacements.  */
1044
1045           /* Extract the displacement from the instruction, sign-extending
1046              it if necessary, then test whether it is within 16 or 32 bits
1047              displacement from GP.  */
1048           insn_disp = insn & 0x0000ffff;
1049           if (insn_disp & 0x00008000)
1050             insn_disp |= 0xffff0000;  /* Negative: sign-extend.  */
1051
1052           xdisp = disp + insn_disp;
1053           fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1054           fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1055
1056           if (fits16)
1057             {
1058               /* Take the op code and dest from this insn, take the base
1059                  register from the literal insn.  Leave the offset alone.  */
1060               insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1061               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1062                                            R_ALPHA_GPREL16);
1063               urel->r_addend = irel->r_addend;
1064               info->changed_relocs = true;
1065
1066               bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1067               info->changed_contents = true;
1068             }
1069
1070           /* If all mem+byte, we can optimize 32-bit mem displacements.  */
1071           else if (fits32 && !(flags & ~6))
1072             {
1073               /* FIXME: sanity check that lit insn Ra is mem insn Rb.  */
1074
1075               irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1076                                            R_ALPHA_GPRELHIGH);
1077               lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1078               bfd_put_32 (info->abfd, lit_insn,
1079                           info->contents + irel->r_offset);
1080               lit_reused = true;
1081               info->changed_contents = true;
1082
1083               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1084                                            R_ALPHA_GPRELLOW);
1085               urel->r_addend = irel->r_addend;
1086               info->changed_relocs = true;
1087             }
1088           else
1089             all_optimized = false;
1090           break;
1091
1092         case 2: /* BYTE OFFSET FORMAT */
1093           /* We can always optimize byte instructions.  */
1094
1095           /* FIXME: sanity check the insn for byte op.  Check that the
1096              literal dest reg is indeed Rb in the byte insn.  */
1097
1098           insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1099
1100           urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1101           urel->r_addend = 0;
1102           info->changed_relocs = true;
1103
1104           bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1105           info->changed_contents = true;
1106           break;
1107
1108         case 3: /* CALL FORMAT */
1109           {
1110             /* If not zero, place to jump without needing pv.  */
1111             bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1112             bfd_vma org = (info->sec->output_section->vma
1113                            + info->sec->output_offset
1114                            + urel->r_offset + 4);
1115             bfd_signed_vma odisp;
1116
1117             odisp = (optdest ? optdest : symval) - org;
1118             if (odisp >= -0x400000 && odisp < 0x400000)
1119               {
1120                 Elf_Internal_Rela *xrel;
1121
1122                 /* Preserve branch prediction call stack when possible.  */
1123                 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1124                   insn = (OP_BSR << 26) | (insn & 0x03e00000);
1125                 else
1126                   insn = (OP_BR << 26) | (insn & 0x03e00000);
1127
1128                 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1129                                              R_ALPHA_BRADDR);
1130                 urel->r_addend = irel->r_addend;
1131
1132                 if (optdest)
1133                   urel->r_addend += optdest - symval;
1134                 else
1135                   all_optimized = false;
1136
1137                 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1138
1139                 /* Kill any HINT reloc that might exist for this insn.  */
1140                 xrel = (elf64_alpha_find_reloc_at_ofs
1141                         (info->relocs, info->relend, urel->r_offset,
1142                          R_ALPHA_HINT));
1143                 if (xrel)
1144                   xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1145
1146                 info->changed_contents = true;
1147                 info->changed_relocs = true;
1148               }
1149             else
1150               all_optimized = false;
1151
1152             /* ??? If target gp == current gp we can eliminate the gp reload.
1153                This does depend on every place a gp could be reloaded will
1154                be, which currently happens for all code produced by gcc, but
1155                not necessarily by hand-coded assembly, or if sibling calls
1156                are enabled in gcc.
1157
1158                Perhaps conditionalize this on a flag being set in the target
1159                object file's header, and have gcc set it?  */
1160           }
1161           break;
1162         }
1163     }
1164
1165   /* If all cases were optimized, we can reduce the use count on this
1166      got entry by one, possibly eliminating it.  */
1167   if (all_optimized)
1168     {
1169       info->gotent->use_count -= 1;
1170       alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1171       if (!info->h)
1172         alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1173
1174       /* If the literal instruction is no longer needed (it may have been
1175          reused.  We can eliminate it.
1176          ??? For now, I don't want to deal with compacting the section,
1177          so just nop it out.  */
1178       if (!lit_reused)
1179         {
1180           irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1181           info->changed_relocs = true;
1182
1183           bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1184           info->changed_contents = true;
1185         }
1186     }
1187
1188   return irel + count;
1189 }
1190
1191 static bfd_vma
1192 elf64_alpha_relax_opt_call (info, symval)
1193      struct alpha_relax_info *info;
1194      bfd_vma symval;
1195 {
1196   /* If the function has the same gp, and we can identify that the
1197      function does not use its function pointer, we can eliminate the
1198      address load.  */
1199
1200   /* If the symbol is marked NOPV, we are being told the function never
1201      needs its procedure value.  */
1202   if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1203     return symval;
1204
1205   /* If the symbol is marked STD_GP, we are being told the function does
1206      a normal ldgp in the first two words.  */
1207   else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1208     ;
1209
1210   /* Otherwise, we may be able to identify a GP load in the first two
1211      words, which we can then skip.  */
1212   else
1213     {
1214       Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1215       bfd_vma ofs;
1216
1217       /* Load the relocations from the section that the target symbol is in.  */
1218       if (info->sec == info->tsec)
1219         {
1220           tsec_relocs = info->relocs;
1221           tsec_relend = info->relend;
1222           tsec_free = NULL;
1223         }
1224       else
1225         {
1226           tsec_relocs = (_bfd_elf64_link_read_relocs
1227                          (info->abfd, info->tsec, (PTR) NULL,
1228                          (Elf_Internal_Rela *) NULL,
1229                          info->link_info->keep_memory));
1230           if (tsec_relocs == NULL)
1231             return 0;
1232           tsec_relend = tsec_relocs + info->tsec->reloc_count;
1233           tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1234         }
1235
1236       /* Recover the symbol's offset within the section.  */
1237       ofs = (symval - info->tsec->output_section->vma
1238              - info->tsec->output_offset);
1239
1240       /* Look for a GPDISP reloc.  */
1241       gpdisp = (elf64_alpha_find_reloc_at_ofs
1242                 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1243
1244       if (!gpdisp || gpdisp->r_addend != 4)
1245         {
1246           if (tsec_free)
1247             free (tsec_free);
1248           return 0;
1249         }
1250       if (tsec_free)
1251         free (tsec_free);
1252     }
1253
1254   /* We've now determined that we can skip an initial gp load.  Verify
1255      that the call and the target use the same gp.   */
1256   if (info->link_info->hash->creator != info->tsec->owner->xvec
1257       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1258     return 0;
1259
1260   return symval + 8;
1261 }
1262
1263 static boolean
1264 elf64_alpha_relax_without_lituse (info, symval, irel)
1265      struct alpha_relax_info *info;
1266      bfd_vma symval;
1267      Elf_Internal_Rela *irel;
1268 {
1269   unsigned int insn;
1270   bfd_signed_vma disp;
1271
1272   /* Get the instruction.  */
1273   insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1274
1275   if (insn >> 26 != OP_LDQ)
1276     {
1277       ((*_bfd_error_handler)
1278        ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1279         bfd_get_filename (info->abfd), info->sec->name,
1280         (unsigned long) irel->r_offset));
1281       return true;
1282     }
1283
1284   /* So we aren't told much.  Do what we can with the address load and
1285      fake the rest.  All of the optimizations here require that the
1286      offset from the GP fit in 16 bits.  */
1287
1288   disp = symval - info->gp;
1289   if (disp < -0x8000 || disp >= 0x8000)
1290     return true;
1291
1292   /* On the LITERAL instruction itself, consider exchanging
1293      `ldq R,X(gp)' for `lda R,Y(gp)'.  */
1294
1295   insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1296   bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1297   info->changed_contents = true;
1298
1299   irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1300   info->changed_relocs = true;
1301
1302   /* Reduce the use count on this got entry by one, possibly
1303      eliminating it.  */
1304   info->gotent->use_count -= 1;
1305   alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1306   if (!info->h)
1307     alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1308
1309   /* ??? Search forward through this basic block looking for insns
1310      that use the target register.  Stop after an insn modifying the
1311      register is seen, or after a branch or call.
1312
1313      Any such memory load insn may be substituted by a load directly
1314      off the GP.  This allows the memory load insn to be issued before
1315      the calculated GP register would otherwise be ready.
1316
1317      Any such jsr insn can be replaced by a bsr if it is in range.
1318
1319      This would mean that we'd have to _add_ relocations, the pain of
1320      which gives one pause.  */
1321
1322   return true;
1323 }
1324
1325 static boolean
1326 elf64_alpha_relax_section (abfd, sec, link_info, again)
1327      bfd *abfd;
1328      asection *sec;
1329      struct bfd_link_info *link_info;
1330      boolean *again;
1331 {
1332   Elf_Internal_Shdr *symtab_hdr;
1333   Elf_Internal_Rela *internal_relocs;
1334   Elf_Internal_Rela *free_relocs = NULL;
1335   Elf_Internal_Rela *irel, *irelend;
1336   bfd_byte *free_contents = NULL;
1337   Elf64_External_Sym *extsyms = NULL;
1338   Elf64_External_Sym *free_extsyms = NULL;
1339   struct alpha_elf_got_entry **local_got_entries;
1340   struct alpha_relax_info info;
1341
1342   /* We are not currently changing any sizes, so only one pass.  */
1343   *again = false;
1344
1345   if (link_info->relocateable
1346       || (sec->flags & SEC_RELOC) == 0
1347       || sec->reloc_count == 0)
1348     return true;
1349
1350   /* If this is the first time we have been called for this section,
1351      initialize the cooked size.  */
1352   if (sec->_cooked_size == 0)
1353     sec->_cooked_size = sec->_raw_size;
1354
1355   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1356   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1357
1358   /* Load the relocations for this section.  */
1359   internal_relocs = (_bfd_elf64_link_read_relocs
1360                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1361                       link_info->keep_memory));
1362   if (internal_relocs == NULL)
1363     goto error_return;
1364   if (! link_info->keep_memory)
1365     free_relocs = internal_relocs;
1366
1367   memset(&info, 0, sizeof (info));
1368   info.abfd = abfd;
1369   info.sec = sec;
1370   info.link_info = link_info;
1371   info.relocs = internal_relocs;
1372   info.relend = irelend = internal_relocs + sec->reloc_count;
1373
1374   /* Find the GP for this object.  */
1375   info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1376   if (info.gotobj)
1377     {
1378       asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1379       info.gp = _bfd_get_gp_value (info.gotobj);
1380       if (info.gp == 0)
1381         {
1382           info.gp = (sgot->output_section->vma
1383                      + sgot->output_offset
1384                      + 0x8000);
1385           _bfd_set_gp_value (info.gotobj, info.gp);
1386         }
1387     }
1388
1389   for (irel = internal_relocs; irel < irelend; irel++)
1390     {
1391       bfd_vma symval;
1392       Elf_Internal_Sym isym;
1393       struct alpha_elf_got_entry *gotent;
1394
1395       if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1396         continue;
1397
1398       /* Get the section contents.  */
1399       if (info.contents == NULL)
1400         {
1401           if (elf_section_data (sec)->this_hdr.contents != NULL)
1402             info.contents = elf_section_data (sec)->this_hdr.contents;
1403           else
1404             {
1405               info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1406               if (info.contents == NULL)
1407                 goto error_return;
1408               free_contents = info.contents;
1409
1410               if (! bfd_get_section_contents (abfd, sec, info.contents,
1411                                               (file_ptr) 0, sec->_raw_size))
1412                 goto error_return;
1413             }
1414         }
1415
1416       /* Read this BFD's symbols if we haven't done so already.  */
1417       if (extsyms == NULL)
1418         {
1419           if (symtab_hdr->contents != NULL)
1420             extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1421           else
1422             {
1423               extsyms = ((Elf64_External_Sym *)
1424                          bfd_malloc (symtab_hdr->sh_size));
1425               if (extsyms == NULL)
1426                 goto error_return;
1427               free_extsyms = extsyms;
1428               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1429                   || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1430                       != symtab_hdr->sh_size))
1431                 goto error_return;
1432             }
1433         }
1434
1435       /* Get the value of the symbol referred to by the reloc.  */
1436       if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1437         {
1438           /* A local symbol.  */
1439           bfd_elf64_swap_symbol_in (abfd,
1440                                     extsyms + ELF64_R_SYM (irel->r_info),
1441                                     &isym);
1442           if (isym.st_shndx == SHN_UNDEF)
1443             info.tsec = bfd_und_section_ptr;
1444           else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1445             info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1446           else if (isym.st_shndx == SHN_ABS)
1447             info.tsec = bfd_abs_section_ptr;
1448           else if (isym.st_shndx == SHN_COMMON)
1449             info.tsec = bfd_com_section_ptr;
1450           else
1451             continue;   /* who knows.  */
1452
1453           info.h = NULL;
1454           info.other = isym.st_other;
1455           gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1456           symval = isym.st_value;
1457         }
1458       else
1459         {
1460           unsigned long indx;
1461           struct alpha_elf_link_hash_entry *h;
1462
1463           indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1464           h = alpha_elf_sym_hashes (abfd)[indx];
1465           BFD_ASSERT (h != NULL);
1466
1467           while (h->root.root.type == bfd_link_hash_indirect
1468                  || h->root.root.type == bfd_link_hash_warning)
1469             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1470
1471           /* We can't do anthing with undefined or dynamic symbols.  */
1472           if (h->root.root.type == bfd_link_hash_undefined
1473               || h->root.root.type == bfd_link_hash_undefweak
1474               || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1475             continue;
1476
1477           info.h = h;
1478           info.tsec = h->root.root.u.def.section;
1479           info.other = h->root.other;
1480           gotent = h->got_entries;
1481           symval = h->root.root.u.def.value;
1482         }
1483
1484       /* Search for the got entry to be used by this relocation.  */
1485       while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1486         gotent = gotent->next;
1487       info.gotent = gotent;
1488
1489       symval += info.tsec->output_section->vma + info.tsec->output_offset;
1490       symval += irel->r_addend;
1491
1492       BFD_ASSERT(info.gotent != NULL);
1493
1494       /* If there exist LITUSE relocations immediately following, this
1495          opens up all sorts of interesting optimizations, because we
1496          now know every location that this address load is used.  */
1497
1498       if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1499         {
1500           irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1501           if (irel == NULL)
1502             goto error_return;
1503         }
1504       else
1505         {
1506           if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1507             goto error_return;
1508         }
1509     }
1510
1511   if (!elf64_alpha_size_got_sections (abfd, link_info))
1512     return false;
1513
1514   if (info.changed_relocs)
1515     {
1516       elf_section_data (sec)->relocs = internal_relocs;
1517     }
1518   else if (free_relocs != NULL)
1519     {
1520       free (free_relocs);
1521     }
1522
1523   if (info.changed_contents)
1524     {
1525       elf_section_data (sec)->this_hdr.contents = info.contents;
1526     }
1527   else if (free_contents != NULL)
1528     {
1529       if (! link_info->keep_memory)
1530         free (free_contents);
1531       else
1532         {
1533           /* Cache the section contents for elf_link_input_bfd.  */
1534           elf_section_data (sec)->this_hdr.contents = info.contents;
1535         }
1536     }
1537
1538   if (free_extsyms != NULL)
1539     {
1540       if (! link_info->keep_memory)
1541         free (free_extsyms);
1542       else
1543         {
1544           /* Cache the symbols for elf_link_input_bfd.  */
1545           symtab_hdr->contents = extsyms;
1546         }
1547     }
1548
1549   *again = info.changed_contents || info.changed_relocs;
1550
1551   return true;
1552
1553  error_return:
1554   if (free_relocs != NULL)
1555     free (free_relocs);
1556   if (free_contents != NULL)
1557     free (free_contents);
1558   if (free_extsyms != NULL)
1559     free (free_extsyms);
1560   return false;
1561 }
1562 \f
1563 /* PLT/GOT Stuff */
1564 #define PLT_HEADER_SIZE 32
1565 #define PLT_HEADER_WORD1        0xc3600000      /* br   $27,.+4     */
1566 #define PLT_HEADER_WORD2        0xa77b000c      /* ldq  $27,12($27) */
1567 #define PLT_HEADER_WORD3        0x47ff041f      /* nop              */
1568 #define PLT_HEADER_WORD4        0x6b7b0000      /* jmp  $27,($27)   */
1569
1570 #define PLT_ENTRY_SIZE 12
1571 #define PLT_ENTRY_WORD1         0xc3800000      /* br   $28, plt0   */
1572 #define PLT_ENTRY_WORD2         0
1573 #define PLT_ENTRY_WORD3         0
1574
1575 #define MAX_GOT_ENTRIES         (64*1024 / 8)
1576
1577 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1578 \f
1579 /* Handle an Alpha specific section when reading an object file.  This
1580    is called when elfcode.h finds a section with an unknown type.
1581    FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1582    how to.  */
1583
1584 static boolean
1585 elf64_alpha_section_from_shdr (abfd, hdr, name)
1586      bfd *abfd;
1587      Elf64_Internal_Shdr *hdr;
1588      char *name;
1589 {
1590   asection *newsect;
1591
1592   /* There ought to be a place to keep ELF backend specific flags, but
1593      at the moment there isn't one.  We just keep track of the
1594      sections by their name, instead.  Fortunately, the ABI gives
1595      suggested names for all the MIPS specific sections, so we will
1596      probably get away with this.  */
1597   switch (hdr->sh_type)
1598     {
1599     case SHT_ALPHA_DEBUG:
1600       if (strcmp (name, ".mdebug") != 0)
1601         return false;
1602       break;
1603 #ifdef ERIC_neverdef
1604     case SHT_ALPHA_REGINFO:
1605       if (strcmp (name, ".reginfo") != 0
1606           || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1607         return false;
1608       break;
1609 #endif
1610     default:
1611       return false;
1612     }
1613
1614   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1615     return false;
1616   newsect = hdr->bfd_section;
1617
1618   if (hdr->sh_type == SHT_ALPHA_DEBUG)
1619     {
1620       if (! bfd_set_section_flags (abfd, newsect,
1621                                    (bfd_get_section_flags (abfd, newsect)
1622                                     | SEC_DEBUGGING)))
1623         return false;
1624     }
1625
1626 #ifdef ERIC_neverdef
1627   /* For a .reginfo section, set the gp value in the tdata information
1628      from the contents of this section.  We need the gp value while
1629      processing relocs, so we just get it now.  */
1630   if (hdr->sh_type == SHT_ALPHA_REGINFO)
1631     {
1632       Elf64_External_RegInfo ext;
1633       Elf64_RegInfo s;
1634
1635       if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1636                                       (file_ptr) 0, sizeof ext))
1637         return false;
1638       bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1639       elf_gp (abfd) = s.ri_gp_value;
1640     }
1641 #endif
1642
1643   return true;
1644 }
1645
1646 /* Set the correct type for an Alpha ELF section.  We do this by the
1647    section name, which is a hack, but ought to work.  */
1648
1649 static boolean
1650 elf64_alpha_fake_sections (abfd, hdr, sec)
1651      bfd *abfd;
1652      Elf64_Internal_Shdr *hdr;
1653      asection *sec;
1654 {
1655   register const char *name;
1656
1657   name = bfd_get_section_name (abfd, sec);
1658
1659   if (strcmp (name, ".mdebug") == 0)
1660     {
1661       hdr->sh_type = SHT_ALPHA_DEBUG;
1662       /* In a shared object on Irix 5.3, the .mdebug section has an
1663          entsize of 0.  FIXME: Does this matter?  */
1664       if ((abfd->flags & DYNAMIC) != 0 )
1665         hdr->sh_entsize = 0;
1666       else
1667         hdr->sh_entsize = 1;
1668     }
1669 #ifdef ERIC_neverdef
1670   else if (strcmp (name, ".reginfo") == 0)
1671     {
1672       hdr->sh_type = SHT_ALPHA_REGINFO;
1673       /* In a shared object on Irix 5.3, the .reginfo section has an
1674          entsize of 0x18.  FIXME: Does this matter?  */
1675       if ((abfd->flags & DYNAMIC) != 0)
1676         hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1677       else
1678         hdr->sh_entsize = 1;
1679
1680       /* Force the section size to the correct value, even if the
1681          linker thinks it is larger.  The link routine below will only
1682          write out this much data for .reginfo.  */
1683       hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1684     }
1685   else if (strcmp (name, ".hash") == 0
1686            || strcmp (name, ".dynamic") == 0
1687            || strcmp (name, ".dynstr") == 0)
1688     {
1689       hdr->sh_entsize = 0;
1690       hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1691     }
1692 #endif
1693   else if (strcmp (name, ".sdata") == 0
1694            || strcmp (name, ".sbss") == 0
1695            || strcmp (name, ".lit4") == 0
1696            || strcmp (name, ".lit8") == 0)
1697     hdr->sh_flags |= SHF_ALPHA_GPREL;
1698
1699   return true;
1700 }
1701
1702 /* Hook called by the linker routine which adds symbols from an object
1703    file.  We use it to put .comm items in .sbss, and not .bss.  */
1704
1705 static boolean
1706 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1707      bfd *abfd;
1708      struct bfd_link_info *info;
1709      const Elf_Internal_Sym *sym;
1710      const char **namep ATTRIBUTE_UNUSED;
1711      flagword *flagsp ATTRIBUTE_UNUSED;
1712      asection **secp;
1713      bfd_vma *valp;
1714 {
1715   if (sym->st_shndx == SHN_COMMON
1716       && !info->relocateable
1717       && sym->st_size <= elf_gp_size (abfd))
1718     {
1719       /* Common symbols less than or equal to -G nn bytes are
1720          automatically put into .sbss.  */
1721
1722       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1723
1724       if (scomm == NULL)
1725         {
1726           scomm = bfd_make_section (abfd, ".scommon");
1727           if (scomm == NULL
1728               || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1729                                                        | SEC_IS_COMMON
1730                                                        | SEC_LINKER_CREATED)))
1731             return false;
1732         }
1733
1734       *secp = scomm;
1735       *valp = sym->st_size;
1736     }
1737
1738   return true;
1739 }
1740
1741 /* Create the .got section.  */
1742
1743 static boolean
1744 elf64_alpha_create_got_section(abfd, info)
1745      bfd *abfd;
1746      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1747 {
1748   asection *s;
1749
1750   if (bfd_get_section_by_name (abfd, ".got"))
1751     return true;
1752
1753   s = bfd_make_section (abfd, ".got");
1754   if (s == NULL
1755       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1756                                            | SEC_HAS_CONTENTS
1757                                            | SEC_IN_MEMORY
1758                                            | SEC_LINKER_CREATED))
1759       || !bfd_set_section_alignment (abfd, s, 3))
1760     return false;
1761
1762   alpha_elf_tdata (abfd)->got = s;
1763
1764   return true;
1765 }
1766
1767 /* Create all the dynamic sections.  */
1768
1769 static boolean
1770 elf64_alpha_create_dynamic_sections (abfd, info)
1771      bfd *abfd;
1772      struct bfd_link_info *info;
1773 {
1774   asection *s;
1775   struct elf_link_hash_entry *h;
1776
1777   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
1778
1779   s = bfd_make_section (abfd, ".plt");
1780   if (s == NULL
1781       || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1782                                             | SEC_HAS_CONTENTS
1783                                             | SEC_IN_MEMORY
1784                                             | SEC_LINKER_CREATED
1785                                             | SEC_CODE))
1786       || ! bfd_set_section_alignment (abfd, s, 3))
1787     return false;
1788
1789   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1790      .plt section.  */
1791   h = NULL;
1792   if (! (_bfd_generic_link_add_one_symbol
1793          (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1794           (bfd_vma) 0, (const char *) NULL, false,
1795           get_elf_backend_data (abfd)->collect,
1796           (struct bfd_link_hash_entry **) &h)))
1797     return false;
1798   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1799   h->type = STT_OBJECT;
1800
1801   if (info->shared
1802       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1803     return false;
1804
1805   s = bfd_make_section (abfd, ".rela.plt");
1806   if (s == NULL
1807       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1808                                            | SEC_HAS_CONTENTS
1809                                            | SEC_IN_MEMORY
1810                                            | SEC_LINKER_CREATED
1811                                            | SEC_READONLY))
1812       || ! bfd_set_section_alignment (abfd, s, 3))
1813     return false;
1814
1815   /* We may or may not have created a .got section for this object, but
1816      we definitely havn't done the rest of the work.  */
1817
1818   if (!elf64_alpha_create_got_section (abfd, info))
1819     return false;
1820
1821   s = bfd_make_section(abfd, ".rela.got");
1822   if (s == NULL
1823       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1824                                            | SEC_HAS_CONTENTS
1825                                            | SEC_IN_MEMORY
1826                                            | SEC_LINKER_CREATED
1827                                            | SEC_READONLY))
1828       || !bfd_set_section_alignment (abfd, s, 3))
1829     return false;
1830
1831   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1832      dynobj's .got section.  We don't do this in the linker script
1833      because we don't want to define the symbol if we are not creating
1834      a global offset table.  */
1835   h = NULL;
1836   if (!(_bfd_generic_link_add_one_symbol
1837         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1838          alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1839          false, get_elf_backend_data (abfd)->collect,
1840          (struct bfd_link_hash_entry **) &h)))
1841     return false;
1842   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1843   h->type = STT_OBJECT;
1844
1845   if (info->shared
1846       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1847     return false;
1848
1849   elf_hash_table (info)->hgot = h;
1850
1851   return true;
1852 }
1853 \f
1854 /* Read ECOFF debugging information from a .mdebug section into a
1855    ecoff_debug_info structure.  */
1856
1857 static boolean
1858 elf64_alpha_read_ecoff_info (abfd, section, debug)
1859      bfd *abfd;
1860      asection *section;
1861      struct ecoff_debug_info *debug;
1862 {
1863   HDRR *symhdr;
1864   const struct ecoff_debug_swap *swap;
1865   char *ext_hdr = NULL;
1866
1867   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1868   memset (debug, 0, sizeof (*debug));
1869
1870   ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
1871   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1872     goto error_return;
1873
1874   if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1875                                 swap->external_hdr_size)
1876       == false)
1877     goto error_return;
1878
1879   symhdr = &debug->symbolic_header;
1880   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1881
1882   /* The symbolic header contains absolute file offsets and sizes to
1883      read.  */
1884 #define READ(ptr, offset, count, size, type)                            \
1885   if (symhdr->count == 0)                                               \
1886     debug->ptr = NULL;                                                  \
1887   else                                                                  \
1888     {                                                                   \
1889       debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1890       if (debug->ptr == NULL)                                           \
1891         goto error_return;                                              \
1892       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
1893           || (bfd_read (debug->ptr, size, symhdr->count,                \
1894                         abfd) != size * symhdr->count))                 \
1895         goto error_return;                                              \
1896     }
1897
1898   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1899   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1900   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1901   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1902   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1903   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1904         union aux_ext *);
1905   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1906   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1907   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1908   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1909   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1910 #undef READ
1911
1912   debug->fdr = NULL;
1913   debug->adjust = NULL;
1914
1915   return true;
1916
1917  error_return:
1918   if (ext_hdr != NULL)
1919     free (ext_hdr);
1920   if (debug->line != NULL)
1921     free (debug->line);
1922   if (debug->external_dnr != NULL)
1923     free (debug->external_dnr);
1924   if (debug->external_pdr != NULL)
1925     free (debug->external_pdr);
1926   if (debug->external_sym != NULL)
1927     free (debug->external_sym);
1928   if (debug->external_opt != NULL)
1929     free (debug->external_opt);
1930   if (debug->external_aux != NULL)
1931     free (debug->external_aux);
1932   if (debug->ss != NULL)
1933     free (debug->ss);
1934   if (debug->ssext != NULL)
1935     free (debug->ssext);
1936   if (debug->external_fdr != NULL)
1937     free (debug->external_fdr);
1938   if (debug->external_rfd != NULL)
1939     free (debug->external_rfd);
1940   if (debug->external_ext != NULL)
1941     free (debug->external_ext);
1942   return false;
1943 }
1944
1945 /* Alpha ELF local labels start with '$'.  */
1946
1947 static boolean
1948 elf64_alpha_is_local_label_name (abfd, name)
1949      bfd *abfd ATTRIBUTE_UNUSED;
1950      const char *name;
1951 {
1952   return name[0] == '$';
1953 }
1954
1955 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1956    routine in order to handle the ECOFF debugging information.  We
1957    still call this mips_elf_find_line because of the slot
1958    find_line_info in elf_obj_tdata is declared that way.  */
1959
1960 struct mips_elf_find_line
1961 {
1962   struct ecoff_debug_info d;
1963   struct ecoff_find_line i;
1964 };
1965
1966 static boolean
1967 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
1968                                functionname_ptr, line_ptr)
1969      bfd *abfd;
1970      asection *section;
1971      asymbol **symbols;
1972      bfd_vma offset;
1973      const char **filename_ptr;
1974      const char **functionname_ptr;
1975      unsigned int *line_ptr;
1976 {
1977   asection *msec;
1978
1979   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1980                                      filename_ptr, functionname_ptr,
1981                                      line_ptr, 0,
1982                                      &elf_tdata (abfd)->dwarf2_find_line_info))
1983     return true;
1984
1985   msec = bfd_get_section_by_name (abfd, ".mdebug");
1986   if (msec != NULL)
1987     {
1988       flagword origflags;
1989       struct mips_elf_find_line *fi;
1990       const struct ecoff_debug_swap * const swap =
1991         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1992
1993       /* If we are called during a link, alpha_elf_final_link may have
1994          cleared the SEC_HAS_CONTENTS field.  We force it back on here
1995          if appropriate (which it normally will be).  */
1996       origflags = msec->flags;
1997       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1998         msec->flags |= SEC_HAS_CONTENTS;
1999
2000       fi = elf_tdata (abfd)->find_line_info;
2001       if (fi == NULL)
2002         {
2003           bfd_size_type external_fdr_size;
2004           char *fraw_src;
2005           char *fraw_end;
2006           struct fdr *fdr_ptr;
2007
2008           fi = ((struct mips_elf_find_line *)
2009                 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2010           if (fi == NULL)
2011             {
2012               msec->flags = origflags;
2013               return false;
2014             }
2015
2016           if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2017             {
2018               msec->flags = origflags;
2019               return false;
2020             }
2021
2022           /* Swap in the FDR information.  */
2023           fi->d.fdr = ((struct fdr *)
2024                        bfd_alloc (abfd,
2025                                   (fi->d.symbolic_header.ifdMax *
2026                                    sizeof (struct fdr))));
2027           if (fi->d.fdr == NULL)
2028             {
2029               msec->flags = origflags;
2030               return false;
2031             }
2032           external_fdr_size = swap->external_fdr_size;
2033           fdr_ptr = fi->d.fdr;
2034           fraw_src = (char *) fi->d.external_fdr;
2035           fraw_end = (fraw_src
2036                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
2037           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2038             (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2039
2040           elf_tdata (abfd)->find_line_info = fi;
2041
2042           /* Note that we don't bother to ever free this information.
2043              find_nearest_line is either called all the time, as in
2044              objdump -l, so the information should be saved, or it is
2045              rarely called, as in ld error messages, so the memory
2046              wasted is unimportant.  Still, it would probably be a
2047              good idea for free_cached_info to throw it away.  */
2048         }
2049
2050       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2051                                   &fi->i, filename_ptr, functionname_ptr,
2052                                   line_ptr))
2053         {
2054           msec->flags = origflags;
2055           return true;
2056         }
2057
2058       msec->flags = origflags;
2059     }
2060
2061   /* Fall back on the generic ELF find_nearest_line routine.  */
2062
2063   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2064                                      filename_ptr, functionname_ptr,
2065                                      line_ptr);
2066 }
2067 \f
2068 /* Structure used to pass information to alpha_elf_output_extsym.  */
2069
2070 struct extsym_info
2071 {
2072   bfd *abfd;
2073   struct bfd_link_info *info;
2074   struct ecoff_debug_info *debug;
2075   const struct ecoff_debug_swap *swap;
2076   boolean failed;
2077 };
2078
2079 static boolean
2080 elf64_alpha_output_extsym (h, data)
2081      struct alpha_elf_link_hash_entry *h;
2082      PTR data;
2083 {
2084   struct extsym_info *einfo = (struct extsym_info *) data;
2085   boolean strip;
2086   asection *sec, *output_section;
2087
2088   if (h->root.indx == -2)
2089     strip = false;
2090   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2091            || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2092           && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2093           && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2094     strip = true;
2095   else if (einfo->info->strip == strip_all
2096           || (einfo->info->strip == strip_some
2097               && bfd_hash_lookup (einfo->info->keep_hash,
2098                                   h->root.root.root.string,
2099                                   false, false) == NULL))
2100     strip = true;
2101   else
2102     strip = false;
2103
2104   if (strip)
2105     return true;
2106
2107   if (h->esym.ifd == -2)
2108     {
2109       h->esym.jmptbl = 0;
2110       h->esym.cobol_main = 0;
2111       h->esym.weakext = 0;
2112       h->esym.reserved = 0;
2113       h->esym.ifd = ifdNil;
2114       h->esym.asym.value = 0;
2115       h->esym.asym.st = stGlobal;
2116
2117       if (h->root.root.type != bfd_link_hash_defined
2118          && h->root.root.type != bfd_link_hash_defweak)
2119        h->esym.asym.sc = scAbs;
2120       else
2121        {
2122          const char *name;
2123
2124          sec = h->root.root.u.def.section;
2125          output_section = sec->output_section;
2126
2127          /* When making a shared library and symbol h is the one from
2128             the another shared library, OUTPUT_SECTION may be null.  */
2129          if (output_section == NULL)
2130            h->esym.asym.sc = scUndefined;
2131          else
2132            {
2133              name = bfd_section_name (output_section->owner, output_section);
2134
2135              if (strcmp (name, ".text") == 0)
2136                h->esym.asym.sc = scText;
2137              else if (strcmp (name, ".data") == 0)
2138                h->esym.asym.sc = scData;
2139              else if (strcmp (name, ".sdata") == 0)
2140                h->esym.asym.sc = scSData;
2141              else if (strcmp (name, ".rodata") == 0
2142                       || strcmp (name, ".rdata") == 0)
2143                h->esym.asym.sc = scRData;
2144              else if (strcmp (name, ".bss") == 0)
2145                h->esym.asym.sc = scBss;
2146              else if (strcmp (name, ".sbss") == 0)
2147                h->esym.asym.sc = scSBss;
2148              else if (strcmp (name, ".init") == 0)
2149                h->esym.asym.sc = scInit;
2150              else if (strcmp (name, ".fini") == 0)
2151                h->esym.asym.sc = scFini;
2152              else
2153                h->esym.asym.sc = scAbs;
2154            }
2155        }
2156
2157       h->esym.asym.reserved = 0;
2158       h->esym.asym.index = indexNil;
2159     }
2160
2161   if (h->root.root.type == bfd_link_hash_common)
2162     h->esym.asym.value = h->root.root.u.c.size;
2163   else if (h->root.root.type == bfd_link_hash_defined
2164            || h->root.root.type == bfd_link_hash_defweak)
2165     {
2166       if (h->esym.asym.sc == scCommon)
2167        h->esym.asym.sc = scBss;
2168       else if (h->esym.asym.sc == scSCommon)
2169        h->esym.asym.sc = scSBss;
2170
2171       sec = h->root.root.u.def.section;
2172       output_section = sec->output_section;
2173       if (output_section != NULL)
2174        h->esym.asym.value = (h->root.root.u.def.value
2175                              + sec->output_offset
2176                              + output_section->vma);
2177       else
2178        h->esym.asym.value = 0;
2179     }
2180   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2181     {
2182       /* Set type and value for a symbol with a function stub.  */
2183       h->esym.asym.st = stProc;
2184       sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2185       if (sec == NULL)
2186         h->esym.asym.value = 0;
2187       else
2188         {
2189           output_section = sec->output_section;
2190           if (output_section != NULL)
2191             h->esym.asym.value = (h->root.plt.offset
2192                                   + sec->output_offset
2193                                   + output_section->vma);
2194           else
2195             h->esym.asym.value = 0;
2196         }
2197 #if 0 /* FIXME?  */
2198       h->esym.ifd = 0;
2199 #endif
2200     }
2201
2202   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2203                                      h->root.root.root.string,
2204                                      &h->esym))
2205     {
2206       einfo->failed = true;
2207       return false;
2208     }
2209
2210   return true;
2211 }
2212
2213 /* FIXME:  Create a runtime procedure table from the .mdebug section.
2214
2215 static boolean
2216 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2217      PTR handle;
2218      bfd *abfd;
2219      struct bfd_link_info *info;
2220      asection *s;
2221      struct ecoff_debug_info *debug;
2222 */
2223 \f
2224 /* Handle dynamic relocations when doing an Alpha ELF link.  */
2225
2226 static boolean
2227 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2228      bfd *abfd;
2229      struct bfd_link_info *info;
2230      asection *sec;
2231      const Elf_Internal_Rela *relocs;
2232 {
2233   bfd *dynobj;
2234   asection *sreloc;
2235   const char *rel_sec_name;
2236   Elf_Internal_Shdr *symtab_hdr;
2237   struct alpha_elf_link_hash_entry **sym_hashes;
2238   struct alpha_elf_got_entry **local_got_entries;
2239   const Elf_Internal_Rela *rel, *relend;
2240   int got_created;
2241
2242   if (info->relocateable)
2243     return true;
2244
2245   dynobj = elf_hash_table(info)->dynobj;
2246   if (dynobj == NULL)
2247     elf_hash_table(info)->dynobj = dynobj = abfd;
2248
2249   sreloc = NULL;
2250   rel_sec_name = NULL;
2251   symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2252   sym_hashes = alpha_elf_sym_hashes(abfd);
2253   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2254   got_created = 0;
2255
2256   relend = relocs + sec->reloc_count;
2257   for (rel = relocs; rel < relend; ++rel)
2258     {
2259       unsigned long r_symndx, r_type;
2260       struct alpha_elf_link_hash_entry *h;
2261
2262       r_symndx = ELF64_R_SYM (rel->r_info);
2263       if (r_symndx < symtab_hdr->sh_info)
2264         h = NULL;
2265       else
2266         {
2267           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2268
2269           while (h->root.root.type == bfd_link_hash_indirect
2270                  || h->root.root.type == bfd_link_hash_warning)
2271             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2272
2273           h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2274         }
2275       r_type = ELF64_R_TYPE (rel->r_info);
2276
2277       switch (r_type)
2278         {
2279         case R_ALPHA_LITERAL:
2280           {
2281             struct alpha_elf_got_entry *gotent;
2282             int flags = 0;
2283
2284             if (h)
2285               {
2286                 /* Search for and possibly create a got entry.  */
2287                 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2288                   if (gotent->gotobj == abfd &&
2289                       gotent->addend == rel->r_addend)
2290                     break;
2291
2292                 if (!gotent)
2293                   {
2294                     gotent = ((struct alpha_elf_got_entry *)
2295                               bfd_alloc (abfd,
2296                                          sizeof (struct alpha_elf_got_entry)));
2297                     if (!gotent)
2298                       return false;
2299
2300                     gotent->gotobj = abfd;
2301                     gotent->addend = rel->r_addend;
2302                     gotent->got_offset = -1;
2303                     gotent->flags = 0;
2304                     gotent->use_count = 1;
2305
2306                     gotent->next = h->got_entries;
2307                     h->got_entries = gotent;
2308
2309                     alpha_elf_tdata (abfd)->total_got_entries++;
2310                   }
2311                 else
2312                   gotent->use_count += 1;
2313               }
2314             else
2315               {
2316                 /* This is a local .got entry -- record for merge.  */
2317                 if (!local_got_entries)
2318                   {
2319                     size_t size;
2320                     size = (symtab_hdr->sh_info
2321                             * sizeof (struct alpha_elf_got_entry *));
2322
2323                     local_got_entries = ((struct alpha_elf_got_entry **)
2324                                          bfd_alloc (abfd, size));
2325                     if (!local_got_entries)
2326                       return false;
2327
2328                     memset (local_got_entries, 0, size);
2329                     alpha_elf_tdata (abfd)->local_got_entries =
2330                       local_got_entries;
2331                   }
2332
2333                 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2334                      gotent != NULL && gotent->addend != rel->r_addend;
2335                      gotent = gotent->next)
2336                   continue;
2337                 if (!gotent)
2338                   {
2339                     gotent = ((struct alpha_elf_got_entry *)
2340                               bfd_alloc (abfd,
2341                                          sizeof (struct alpha_elf_got_entry)));
2342                     if (!gotent)
2343                       return false;
2344
2345                     gotent->gotobj = abfd;
2346                     gotent->addend = rel->r_addend;
2347                     gotent->got_offset = -1;
2348                     gotent->flags = 0;
2349                     gotent->use_count = 1;
2350
2351                     gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2352                     local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2353
2354                     alpha_elf_tdata(abfd)->total_got_entries++;
2355                     alpha_elf_tdata(abfd)->n_local_got_entries++;
2356                   }
2357                 else
2358                   gotent->use_count += 1;
2359               }
2360
2361             /* Remember how this literal is used from its LITUSEs.
2362                This will be important when it comes to decide if we can
2363                create a .plt entry for a function symbol.  */
2364             if (rel+1 < relend
2365                 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2366               {
2367                 do
2368                   {
2369                     ++rel;
2370                     if (rel->r_addend >= 1 && rel->r_addend <= 3)
2371                       flags |= 1 << rel->r_addend;
2372                   }
2373                 while (rel+1 < relend &&
2374                        ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2375               }
2376             else
2377               {
2378                 /* No LITUSEs -- presumably the address is not being
2379                    loaded for nothing.  */
2380                 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2381               }
2382
2383             gotent->flags |= flags;
2384             if (h)
2385               {
2386                 /* Make a guess as to whether a .plt entry will be needed.  */
2387                 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2388                   h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2389                 else
2390                   h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2391               }
2392           }
2393           /* FALLTHRU */
2394
2395         case R_ALPHA_GPDISP:
2396         case R_ALPHA_GPREL16:
2397         case R_ALPHA_GPREL32:
2398         case R_ALPHA_GPRELHIGH:
2399         case R_ALPHA_GPRELLOW:
2400           /* We don't actually use the .got here, but the sections must
2401              be created before the linker maps input sections to output
2402              sections.  */
2403           if (!got_created)
2404             {
2405               if (!elf64_alpha_create_got_section (abfd, info))
2406                 return false;
2407
2408               /* Make sure the object's gotobj is set to itself so
2409                  that we default to every object with its own .got.
2410                  We'll merge .gots later once we've collected each
2411                  object's info.  */
2412               alpha_elf_tdata(abfd)->gotobj = abfd;
2413
2414               got_created = 1;
2415             }
2416           break;
2417
2418         case R_ALPHA_SREL16:
2419         case R_ALPHA_SREL32:
2420         case R_ALPHA_SREL64:
2421           if (h == NULL)
2422             break;
2423           /* FALLTHRU */
2424
2425         case R_ALPHA_REFLONG:
2426         case R_ALPHA_REFQUAD:
2427           if (rel_sec_name == NULL)
2428             {
2429               rel_sec_name = (bfd_elf_string_from_elf_section
2430                               (abfd, elf_elfheader(abfd)->e_shstrndx,
2431                                elf_section_data(sec)->rel_hdr.sh_name));
2432               if (rel_sec_name == NULL)
2433                 return false;
2434
2435               BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2436                           && strcmp (bfd_get_section_name (abfd, sec),
2437                                      rel_sec_name+5) == 0);
2438             }
2439
2440           /* We need to create the section here now whether we eventually
2441              use it or not so that it gets mapped to an output section by
2442              the linker.  If not used, we'll kill it in
2443              size_dynamic_sections.  */
2444           if (sreloc == NULL)
2445             {
2446               sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2447               if (sreloc == NULL)
2448                 {
2449                   sreloc = bfd_make_section (dynobj, rel_sec_name);
2450                   if (sreloc == NULL
2451                       || !bfd_set_section_flags (dynobj, sreloc,
2452                                                  (((sec->flags
2453                                                     & SEC_ALLOC)
2454                                                    ? (SEC_ALLOC
2455                                                       | SEC_LOAD) : 0)
2456                                                   | SEC_HAS_CONTENTS
2457                                                   | SEC_IN_MEMORY
2458                                                   | SEC_LINKER_CREATED
2459                                                   | SEC_READONLY))
2460                       || !bfd_set_section_alignment (dynobj, sreloc, 3))
2461                     return false;
2462                 }
2463             }
2464
2465           if (h)
2466             {
2467               /* Since we havn't seen all of the input symbols yet, we
2468                  don't know whether we'll actually need a dynamic relocation
2469                  entry for this reloc.  So make a record of it.  Once we
2470                  find out if this thing needs dynamic relocation we'll
2471                  expand the relocation sections by the appropriate amount.  */
2472
2473               struct alpha_elf_reloc_entry *rent;
2474
2475               for (rent = h->reloc_entries; rent; rent = rent->next)
2476                 if (rent->rtype == r_type && rent->srel == sreloc)
2477                   break;
2478
2479               if (!rent)
2480                 {
2481                   rent = ((struct alpha_elf_reloc_entry *)
2482                           bfd_alloc (abfd,
2483                                      sizeof (struct alpha_elf_reloc_entry)));
2484                   if (!rent)
2485                     return false;
2486
2487                   rent->srel = sreloc;
2488                   rent->rtype = r_type;
2489                   rent->count = 1;
2490                   rent->reltext = (sec->flags & SEC_READONLY) != 0;
2491
2492                   rent->next = h->reloc_entries;
2493                   h->reloc_entries = rent;
2494                 }
2495               else
2496                 rent->count++;
2497             }
2498           else if (info->shared && (sec->flags & SEC_ALLOC))
2499             {
2500               /* If this is a shared library, and the section is to be
2501                  loaded into memory, we need a RELATIVE reloc.  */
2502               sreloc->_raw_size += sizeof (Elf64_External_Rela);
2503               if (sec->flags & SEC_READONLY)
2504                 info->flags |= DF_TEXTREL;
2505             }
2506           break;
2507         }
2508     }
2509
2510   return true;
2511 }
2512
2513 /* Adjust a symbol defined by a dynamic object and referenced by a
2514    regular object.  The current definition is in some section of the
2515    dynamic object, but we're not including those sections.  We have to
2516    change the definition to something the rest of the link can
2517    understand.  */
2518
2519 static boolean
2520 elf64_alpha_adjust_dynamic_symbol (info, h)
2521      struct bfd_link_info *info;
2522      struct elf_link_hash_entry *h;
2523 {
2524   bfd *dynobj;
2525   asection *s;
2526   struct alpha_elf_link_hash_entry *ah;
2527
2528   dynobj = elf_hash_table(info)->dynobj;
2529   ah = (struct alpha_elf_link_hash_entry *)h;
2530
2531   /* Now that we've seen all of the input symbols, finalize our decision
2532      about whether this symbol should get a .plt entry.  */
2533
2534   if (h->root.type != bfd_link_hash_undefweak
2535       && alpha_elf_dynamic_symbol_p (h, info)
2536       && ((h->type == STT_FUNC
2537            && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2538           || (h->type == STT_NOTYPE
2539               && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2540       /* Don't prevent otherwise valid programs from linking by attempting
2541          to create a new .got entry somewhere.  A Correct Solution would be
2542          to add a new .got section to a new object file and let it be merged
2543          somewhere later.  But for now don't bother.  */
2544       && ah->got_entries)
2545     {
2546       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2547
2548       s = bfd_get_section_by_name(dynobj, ".plt");
2549       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2550         return false;
2551
2552       /* The first bit of the .plt is reserved.  */
2553       if (s->_raw_size == 0)
2554         s->_raw_size = PLT_HEADER_SIZE;
2555
2556       h->plt.offset = s->_raw_size;
2557       s->_raw_size += PLT_ENTRY_SIZE;
2558
2559       /* If this symbol is not defined in a regular file, and we are not
2560          generating a shared library, then set the symbol to the location
2561          in the .plt.  This is required to make function pointers compare
2562          equal between the normal executable and the shared library.  */
2563       if (! info->shared
2564           && h->root.type != bfd_link_hash_defweak)
2565         {
2566           h->root.u.def.section = s;
2567           h->root.u.def.value = h->plt.offset;
2568         }
2569
2570       /* We also need a JMP_SLOT entry in the .rela.plt section.  */
2571       s = bfd_get_section_by_name (dynobj, ".rela.plt");
2572       BFD_ASSERT (s != NULL);
2573       s->_raw_size += sizeof (Elf64_External_Rela);
2574
2575       return true;
2576     }
2577   else
2578     h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2579
2580   /* If this is a weak symbol, and there is a real definition, the
2581      processor independent code will have arranged for us to see the
2582      real definition first, and we can just use the same value.  */
2583   if (h->weakdef != NULL)
2584     {
2585       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2586                   || h->weakdef->root.type == bfd_link_hash_defweak);
2587       h->root.u.def.section = h->weakdef->root.u.def.section;
2588       h->root.u.def.value = h->weakdef->root.u.def.value;
2589       return true;
2590     }
2591
2592   /* This is a reference to a symbol defined by a dynamic object which
2593      is not a function.  The Alpha, since it uses .got entries for all
2594      symbols even in regular objects, does not need the hackery of a
2595      .dynbss section and COPY dynamic relocations.  */
2596
2597   return true;
2598 }
2599
2600 /* Symbol versioning can create new symbols, and make our old symbols
2601    indirect to the new ones.  Consolidate the got and reloc information
2602    in these situations.  */
2603
2604 static boolean
2605 elf64_alpha_merge_ind_symbols (hi, dummy)
2606      struct alpha_elf_link_hash_entry *hi;
2607      PTR dummy ATTRIBUTE_UNUSED;
2608 {
2609   struct alpha_elf_link_hash_entry *hs;
2610
2611   if (hi->root.root.type != bfd_link_hash_indirect)
2612     return true;
2613   hs = hi;
2614   do {
2615     hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2616   } while (hs->root.root.type == bfd_link_hash_indirect);
2617
2618   /* Merge the flags.  Whee.  */
2619
2620   hs->flags |= hi->flags;
2621
2622   /* Merge the .got entries.  Cannibalize the old symbol's list in
2623      doing so, since we don't need it anymore.  */
2624
2625   if (hs->got_entries == NULL)
2626     hs->got_entries = hi->got_entries;
2627   else
2628     {
2629       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2630
2631       gsh = hs->got_entries;
2632       for (gi = hi->got_entries; gi ; gi = gin)
2633         {
2634           gin = gi->next;
2635           for (gs = gsh; gs ; gs = gs->next)
2636             if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2637               goto got_found;
2638           gi->next = hs->got_entries;
2639           hs->got_entries = gi;
2640         got_found:;
2641         }
2642     }
2643   hi->got_entries = NULL;
2644
2645   /* And similar for the reloc entries.  */
2646
2647   if (hs->reloc_entries == NULL)
2648     hs->reloc_entries = hi->reloc_entries;
2649   else
2650     {
2651       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2652
2653       rsh = hs->reloc_entries;
2654       for (ri = hi->reloc_entries; ri ; ri = rin)
2655         {
2656           rin = ri->next;
2657           for (rs = rsh; rs ; rs = rs->next)
2658             if (ri->rtype == rs->rtype)
2659               {
2660                 rs->count += ri->count;
2661                 goto found_reloc;
2662               }
2663           ri->next = hs->reloc_entries;
2664           hs->reloc_entries = ri;
2665         found_reloc:;
2666         }
2667     }
2668   hi->reloc_entries = NULL;
2669
2670   return true;
2671 }
2672
2673 /* Is it possible to merge two object file's .got tables?  */
2674
2675 static boolean
2676 elf64_alpha_can_merge_gots (a, b)
2677      bfd *a, *b;
2678 {
2679   int total = alpha_elf_tdata (a)->total_got_entries;
2680   bfd *bsub;
2681
2682   /* Trivial quick fallout test.  */
2683   if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2684     return true;
2685
2686   /* By their nature, local .got entries cannot be merged.  */
2687   if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2688     return false;
2689
2690   /* Failing the common trivial comparison, we must effectively
2691      perform the merge.  Not actually performing the merge means that
2692      we don't have to store undo information in case we fail.  */
2693   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2694     {
2695       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2696       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2697       int i, n;
2698
2699       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2700       for (i = 0; i < n; ++i)
2701         {
2702           struct alpha_elf_got_entry *ae, *be;
2703           struct alpha_elf_link_hash_entry *h;
2704
2705           h = hashes[i];
2706           while (h->root.root.type == bfd_link_hash_indirect
2707                  || h->root.root.type == bfd_link_hash_warning)
2708             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2709
2710           for (be = h->got_entries; be ; be = be->next)
2711             {
2712               if (be->use_count == 0)
2713                 continue;
2714               if (be->gotobj != b)
2715                 continue;
2716
2717               for (ae = h->got_entries; ae ; ae = ae->next)
2718                 if (ae->gotobj == a && ae->addend == be->addend)
2719                   goto global_found;
2720
2721               if (++total > MAX_GOT_ENTRIES)
2722                 return false;
2723             global_found:;
2724             }
2725         }
2726     }
2727
2728   return true;
2729 }
2730
2731 /* Actually merge two .got tables.  */
2732
2733 static void
2734 elf64_alpha_merge_gots (a, b)
2735      bfd *a, *b;
2736 {
2737   int total = alpha_elf_tdata (a)->total_got_entries;
2738   bfd *bsub;
2739
2740   /* Remember local expansion.  */
2741   {
2742     int e = alpha_elf_tdata (b)->n_local_got_entries;
2743     total += e;
2744     alpha_elf_tdata (a)->n_local_got_entries += e;
2745   }
2746
2747   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2748     {
2749       struct alpha_elf_got_entry **local_got_entries;
2750       struct alpha_elf_link_hash_entry **hashes;
2751       Elf_Internal_Shdr *symtab_hdr;
2752       int i, n;
2753
2754       /* Let the local .got entries know they are part of a new subsegment.  */
2755       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2756       if (local_got_entries)
2757         {
2758           n = elf_tdata (bsub)->symtab_hdr.sh_info;
2759           for (i = 0; i < n; ++i)
2760             {
2761               struct alpha_elf_got_entry *ent;
2762               for (ent = local_got_entries[i]; ent; ent = ent->next)
2763                 ent->gotobj = a;
2764             }
2765         }
2766
2767       /* Merge the global .got entries.  */
2768       hashes = alpha_elf_sym_hashes (bsub);
2769       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2770
2771       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2772       for (i = 0; i < n; ++i)
2773         {
2774           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2775           struct alpha_elf_link_hash_entry *h;
2776
2777           h = hashes[i];
2778           while (h->root.root.type == bfd_link_hash_indirect
2779                  || h->root.root.type == bfd_link_hash_warning)
2780             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2781
2782           start = &h->got_entries;
2783           for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2784             {
2785               if (be->use_count == 0)
2786                 {
2787                   *pbe = be->next;
2788                   continue;
2789                 }
2790               if (be->gotobj != b)
2791                 continue;
2792
2793               for (ae = *start; ae ; ae = ae->next)
2794                 if (ae->gotobj == a && ae->addend == be->addend)
2795                   {
2796                     ae->flags |= be->flags;
2797                     ae->use_count += be->use_count;
2798                     *pbe = be->next;
2799                     goto global_found;
2800                   }
2801               be->gotobj = a;
2802               total += 1;
2803
2804             global_found:;
2805             }
2806         }
2807
2808       alpha_elf_tdata (bsub)->gotobj = a;
2809     }
2810   alpha_elf_tdata (a)->total_got_entries = total;
2811
2812   /* Merge the two in_got chains.  */
2813   {
2814     bfd *next;
2815
2816     bsub = a;
2817     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2818       bsub = next;
2819
2820     alpha_elf_tdata (bsub)->in_got_link_next = b;
2821   }
2822 }
2823
2824 /* Calculate the offsets for the got entries.  */
2825
2826 static boolean
2827 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2828      struct alpha_elf_link_hash_entry *h;
2829      PTR arg ATTRIBUTE_UNUSED;
2830 {
2831   struct alpha_elf_got_entry *gotent;
2832
2833   for (gotent = h->got_entries; gotent; gotent = gotent->next)
2834     if (gotent->use_count > 0)
2835       {
2836         bfd_size_type *plge
2837           = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2838
2839         gotent->got_offset = *plge;
2840         *plge += 8;
2841       }
2842
2843   return true;
2844 }
2845
2846 static void
2847 elf64_alpha_calc_got_offsets (info)
2848      struct bfd_link_info *info;
2849 {
2850   bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2851
2852   /* First, zero out the .got sizes, as we may be recalculating the
2853      .got after optimizing it.  */
2854   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2855     alpha_elf_tdata(i)->got->_raw_size = 0;
2856
2857   /* Next, fill in the offsets for all the global entries.  */
2858   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2859                                 elf64_alpha_calc_got_offsets_for_symbol,
2860                                 NULL);
2861
2862   /* Finally, fill in the offsets for the local entries.  */
2863   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2864     {
2865       bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2866       bfd *j;
2867
2868       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2869         {
2870           struct alpha_elf_got_entry **local_got_entries, *gotent;
2871           int k, n;
2872
2873           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2874           if (!local_got_entries)
2875             continue;
2876
2877           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2878             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2879               if (gotent->use_count > 0)
2880                 {
2881                   gotent->got_offset = got_offset;
2882                   got_offset += 8;
2883                 }
2884         }
2885
2886       alpha_elf_tdata(i)->got->_raw_size = got_offset;
2887       alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2888     }
2889 }
2890
2891 /* Constructs the gots.  */
2892
2893 static boolean
2894 elf64_alpha_size_got_sections (output_bfd, info)
2895      bfd *output_bfd ATTRIBUTE_UNUSED;
2896      struct bfd_link_info *info;
2897 {
2898   bfd *i, *got_list, *cur_got_obj = NULL;
2899   int something_changed = 0;
2900
2901   got_list = alpha_elf_hash_table (info)->got_list;
2902
2903   /* On the first time through, pretend we have an existing got list
2904      consisting of all of the input files.  */
2905   if (got_list == NULL)
2906     {
2907       for (i = info->input_bfds; i ; i = i->link_next)
2908         {
2909           bfd *this_got = alpha_elf_tdata (i)->gotobj;
2910           if (this_got == NULL)
2911             continue;
2912
2913           /* We are assuming no merging has yet ocurred.  */
2914           BFD_ASSERT (this_got == i);
2915
2916           if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2917             {
2918               /* Yikes! A single object file has too many entries.  */
2919               (*_bfd_error_handler)
2920                 (_("%s: .got subsegment exceeds 64K (size %d)"),
2921                  bfd_get_filename (i),
2922                  alpha_elf_tdata (this_got)->total_got_entries * 8);
2923               return false;
2924             }
2925
2926           if (got_list == NULL)
2927             got_list = this_got;
2928           else
2929             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2930           cur_got_obj = this_got;
2931         }
2932
2933       /* Strange degenerate case of no got references.  */
2934       if (got_list == NULL)
2935         return true;
2936
2937       alpha_elf_hash_table (info)->got_list = got_list;
2938
2939       /* Force got offsets to be recalculated.  */
2940       something_changed = 1;
2941     }
2942
2943   cur_got_obj = got_list;
2944   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2945   while (i != NULL)
2946     {
2947       if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2948         {
2949           elf64_alpha_merge_gots (cur_got_obj, i);
2950           i = alpha_elf_tdata(i)->got_link_next;
2951           alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2952           something_changed = 1;
2953         }
2954       else
2955         {
2956           cur_got_obj = i;
2957           i = alpha_elf_tdata(i)->got_link_next;
2958         }
2959     }
2960
2961   /* Once the gots have been merged, fill in the got offsets for
2962      everything therein.  */
2963   if (1 || something_changed)
2964     elf64_alpha_calc_got_offsets (info);
2965
2966   return true;
2967 }
2968
2969 static boolean
2970 elf64_alpha_always_size_sections (output_bfd, info)
2971      bfd *output_bfd;
2972      struct bfd_link_info *info;
2973 {
2974   bfd *i;
2975
2976   if (info->relocateable)
2977     return true;
2978
2979   /* First, take care of the indirect symbols created by versioning.  */
2980   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2981                                 elf64_alpha_merge_ind_symbols,
2982                                 NULL);
2983
2984   if (!elf64_alpha_size_got_sections (output_bfd, info))
2985     return false;
2986
2987   /* Allocate space for all of the .got subsections.  */
2988   i = alpha_elf_hash_table (info)->got_list;
2989   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2990     {
2991       asection *s = alpha_elf_tdata(i)->got;
2992       if (s->_raw_size > 0)
2993         {
2994           s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
2995           if (s->contents == NULL)
2996             return false;
2997         }
2998     }
2999
3000   return true;
3001 }
3002
3003 /* Work out the sizes of the dynamic relocation entries.  */
3004
3005 static boolean
3006 elf64_alpha_calc_dynrel_sizes (h, info)
3007      struct alpha_elf_link_hash_entry *h;
3008      struct bfd_link_info *info;
3009 {
3010   /* If the symbol was defined as a common symbol in a regular object
3011      file, and there was no definition in any dynamic object, then the
3012      linker will have allocated space for the symbol in a common
3013      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3014      set.  This is done for dynamic symbols in
3015      elf_adjust_dynamic_symbol but this is not done for non-dynamic
3016      symbols, somehow.  */
3017   if (((h->root.elf_link_hash_flags
3018        & (ELF_LINK_HASH_DEF_REGULAR
3019           | ELF_LINK_HASH_REF_REGULAR
3020           | ELF_LINK_HASH_DEF_DYNAMIC))
3021        == ELF_LINK_HASH_REF_REGULAR)
3022       && (h->root.root.type == bfd_link_hash_defined
3023           || h->root.root.type == bfd_link_hash_defweak)
3024       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3025     {
3026       h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3027     }
3028
3029   /* If the symbol is dynamic, we'll need all the relocations in their
3030      natural form.  If this is a shared object, and it has been forced
3031      local, we'll need the same number of RELATIVE relocations.  */
3032
3033   if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3034     {
3035       struct alpha_elf_reloc_entry *relent;
3036       bfd *dynobj;
3037       struct alpha_elf_got_entry *gotent;
3038       bfd_size_type count;
3039       asection *srel;
3040
3041       for (relent = h->reloc_entries; relent; relent = relent->next)
3042         if (relent->rtype == R_ALPHA_REFLONG
3043             || relent->rtype == R_ALPHA_REFQUAD)
3044           {
3045             relent->srel->_raw_size +=
3046               sizeof (Elf64_External_Rela) * relent->count;
3047             if (relent->reltext)
3048               info->flags |= DT_TEXTREL;
3049           }
3050
3051       dynobj = elf_hash_table(info)->dynobj;
3052       count = 0;
3053
3054       for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3055         count++;
3056
3057       /* If we are using a .plt entry, subtract one, as the first
3058          reference uses a .rela.plt entry instead.  */
3059       if (h->root.plt.offset != MINUS_ONE)
3060         count--;
3061
3062       if (count > 0)
3063         {
3064           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3065           BFD_ASSERT (srel != NULL);
3066           srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3067         }
3068     }
3069
3070   return true;
3071 }
3072
3073 /* Set the sizes of the dynamic sections.  */
3074
3075 static boolean
3076 elf64_alpha_size_dynamic_sections (output_bfd, info)
3077      bfd *output_bfd ATTRIBUTE_UNUSED;
3078      struct bfd_link_info *info;
3079 {
3080   bfd *dynobj;
3081   asection *s;
3082   boolean relplt;
3083
3084   dynobj = elf_hash_table(info)->dynobj;
3085   BFD_ASSERT(dynobj != NULL);
3086
3087   if (elf_hash_table (info)->dynamic_sections_created)
3088     {
3089       /* Set the contents of the .interp section to the interpreter.  */
3090       if (!info->shared)
3091         {
3092           s = bfd_get_section_by_name (dynobj, ".interp");
3093           BFD_ASSERT (s != NULL);
3094           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3095           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3096         }
3097
3098       /* Now that we've seen all of the input files, we can decide which
3099          symbols need dynamic relocation entries and which don't.  We've
3100          collected information in check_relocs that we can now apply to
3101          size the dynamic relocation sections.  */
3102       alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3103                                     elf64_alpha_calc_dynrel_sizes,
3104                                     info);
3105
3106       /* When building shared libraries, each local .got entry needs a
3107          RELATIVE reloc.  */
3108       if (info->shared)
3109         {
3110           bfd *i;
3111           asection *srel;
3112           bfd_size_type count;
3113
3114           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3115           BFD_ASSERT (srel != NULL);
3116
3117           for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3118                i != NULL;
3119                i = alpha_elf_tdata(i)->got_link_next)
3120             count += alpha_elf_tdata(i)->n_local_got_entries;
3121
3122           srel->_raw_size += count * sizeof (Elf64_External_Rela);
3123         }
3124     }
3125   /* else we're not dynamic and by definition we don't need such things.  */
3126
3127   /* The check_relocs and adjust_dynamic_symbol entry points have
3128      determined the sizes of the various dynamic sections.  Allocate
3129      memory for them.  */
3130   relplt = false;
3131   for (s = dynobj->sections; s != NULL; s = s->next)
3132     {
3133       const char *name;
3134       boolean strip;
3135
3136       if (!(s->flags & SEC_LINKER_CREATED))
3137         continue;
3138
3139       /* It's OK to base decisions on the section name, because none
3140          of the dynobj section names depend upon the input files.  */
3141       name = bfd_get_section_name (dynobj, s);
3142
3143       /* If we don't need this section, strip it from the output file.
3144          This is to handle .rela.bss and .rela.plt.  We must create it
3145          in create_dynamic_sections, because it must be created before
3146          the linker maps input sections to output sections.  The
3147          linker does that before adjust_dynamic_symbol is called, and
3148          it is that function which decides whether anything needs to
3149          go into these sections.  */
3150
3151       strip = false;
3152
3153       if (strncmp (name, ".rela", 5) == 0)
3154         {
3155           strip = (s->_raw_size == 0);
3156
3157           if (!strip)
3158             {
3159               if (strcmp(name, ".rela.plt") == 0)
3160                 relplt = true;
3161
3162               /* We use the reloc_count field as a counter if we need
3163                  to copy relocs into the output file.  */
3164               s->reloc_count = 0;
3165             }
3166         }
3167       else if (strcmp (name, ".plt") != 0)
3168         {
3169           /* It's not one of our dynamic sections, so don't allocate space.  */
3170           continue;
3171         }
3172
3173       if (strip)
3174         _bfd_strip_section_from_output (info, s);
3175       else
3176         {
3177           /* Allocate memory for the section contents.  */
3178           s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3179           if (s->contents == NULL && s->_raw_size != 0)
3180             return false;
3181         }
3182     }
3183
3184   if (elf_hash_table (info)->dynamic_sections_created)
3185     {
3186       /* Add some entries to the .dynamic section.  We fill in the
3187          values later, in elf64_alpha_finish_dynamic_sections, but we
3188          must add the entries now so that we get the correct size for
3189          the .dynamic section.  The DT_DEBUG entry is filled in by the
3190          dynamic linker and used by the debugger.  */
3191       if (!info->shared)
3192         {
3193           if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3194             return false;
3195         }
3196
3197       if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3198         return false;
3199
3200       if (relplt)
3201         {
3202           if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3203               || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3204               || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3205             return false;
3206         }
3207
3208       if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3209           || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3210           || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3211                                             sizeof (Elf64_External_Rela)))
3212         return false;
3213
3214       if (info->flags & DF_TEXTREL)
3215         {
3216           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3217             return false;
3218         }
3219     }
3220
3221   return true;
3222 }
3223
3224 /* Relocate an Alpha ELF section.  */
3225
3226 static boolean
3227 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3228                               contents, relocs, local_syms, local_sections)
3229      bfd *output_bfd;
3230      struct bfd_link_info *info;
3231      bfd *input_bfd;
3232      asection *input_section;
3233      bfd_byte *contents;
3234      Elf_Internal_Rela *relocs;
3235      Elf_Internal_Sym *local_syms;
3236      asection **local_sections;
3237 {
3238   Elf_Internal_Shdr *symtab_hdr;
3239   Elf_Internal_Rela *rel;
3240   Elf_Internal_Rela *relend;
3241   asection *sec, *sgot, *srel, *srelgot;
3242   bfd *dynobj, *gotobj;
3243   bfd_vma gp;
3244
3245   srelgot = srel = NULL;
3246   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3247   dynobj = elf_hash_table (info)->dynobj;
3248   if (dynobj)
3249     {
3250       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3251     }
3252
3253   /* Find the gp value for this input bfd.  */
3254   sgot = NULL;
3255   gp = 0;
3256   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3257   if (gotobj)
3258     {
3259       sgot = alpha_elf_tdata (gotobj)->got;
3260       gp = _bfd_get_gp_value (gotobj);
3261       if (gp == 0)
3262         {
3263           gp = (sgot->output_section->vma
3264                 + sgot->output_offset
3265                 + 0x8000);
3266           _bfd_set_gp_value (gotobj, gp);
3267         }
3268     }
3269
3270   rel = relocs;
3271   relend = relocs + input_section->reloc_count;
3272   for (; rel < relend; rel++)
3273     {
3274       int r_type;
3275       reloc_howto_type *howto;
3276       unsigned long r_symndx;
3277       struct alpha_elf_link_hash_entry *h;
3278       Elf_Internal_Sym *sym;
3279       bfd_vma relocation;
3280       bfd_signed_vma addend;
3281       bfd_reloc_status_type r;
3282
3283       r_type = ELF64_R_TYPE(rel->r_info);
3284       if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3285         {
3286           bfd_set_error (bfd_error_bad_value);
3287           return false;
3288         }
3289       howto = elf64_alpha_howto_table + r_type;
3290
3291       r_symndx = ELF64_R_SYM(rel->r_info);
3292
3293       if (info->relocateable)
3294         {
3295           /* This is a relocateable link.  We don't have to change
3296              anything, unless the reloc is against a section symbol,
3297              in which case we have to adjust according to where the
3298              section symbol winds up in the output section.  */
3299
3300           /* The symbol associated with GPDISP and LITUSE is
3301              immaterial.  Only the addend is significant.  */
3302           if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3303             continue;
3304
3305           if (r_symndx < symtab_hdr->sh_info)
3306             {
3307               sym = local_syms + r_symndx;
3308               if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3309                 {
3310                   sec = local_sections[r_symndx];
3311                   rel->r_addend += sec->output_offset + sym->st_value;
3312                 }
3313             }
3314
3315           continue;
3316         }
3317
3318       /* This is a final link.  */
3319
3320       h = NULL;
3321       sym = NULL;
3322       sec = NULL;
3323
3324       if (r_symndx < symtab_hdr->sh_info)
3325         {
3326           sym = local_syms + r_symndx;
3327           sec = local_sections[r_symndx];
3328           relocation = (sec->output_section->vma
3329                         + sec->output_offset
3330                         + sym->st_value);
3331         }
3332       else
3333         {
3334           h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3335
3336           while (h->root.root.type == bfd_link_hash_indirect
3337                  || h->root.root.type == bfd_link_hash_warning)
3338             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3339
3340           if (h->root.root.type == bfd_link_hash_defined
3341               || h->root.root.type == bfd_link_hash_defweak)
3342             {
3343               sec = h->root.root.u.def.section;
3344
3345 #if rth_notdef
3346               if ((r_type == R_ALPHA_LITERAL
3347                    && elf_hash_table(info)->dynamic_sections_created
3348                    && (!info->shared
3349                        || !info->symbolic
3350                        || !(h->root.elf_link_hash_flags
3351                             & ELF_LINK_HASH_DEF_REGULAR)))
3352                   || (info->shared
3353                       && (!info->symbolic
3354                           || !(h->root.elf_link_hash_flags
3355                                & ELF_LINK_HASH_DEF_REGULAR))
3356                       && (input_section->flags & SEC_ALLOC)
3357                       && (r_type == R_ALPHA_REFLONG
3358                           || r_type == R_ALPHA_REFQUAD
3359                           || r_type == R_ALPHA_LITERAL)))
3360                 {
3361                   /* In these cases, we don't need the relocation value.
3362                      We check specially because in some obscure cases
3363                      sec->output_section will be NULL.  */
3364                   relocation = 0;
3365                 }
3366 #else
3367               /* FIXME: Are not these obscure cases simply bugs?  Let's
3368                  get something working and come back to this.  */
3369               if (sec->output_section == NULL)
3370                 relocation = 0;
3371 #endif /* rth_notdef */
3372               else
3373                 {
3374                   relocation = (h->root.root.u.def.value
3375                                 + sec->output_section->vma
3376                                 + sec->output_offset);
3377                 }
3378             }
3379           else if (h->root.root.type == bfd_link_hash_undefweak)
3380             relocation = 0;
3381           else if (info->shared && !info->symbolic
3382                    && !info->no_undefined
3383                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3384             relocation = 0;
3385           else
3386             {
3387               if (!((*info->callbacks->undefined_symbol)
3388                     (info, h->root.root.root.string, input_bfd,
3389                      input_section, rel->r_offset,
3390                      (!info->shared || info->no_undefined
3391                       || ELF_ST_VISIBILITY (h->root.other)))))
3392                 return false;
3393               relocation = 0;
3394             }
3395         }
3396       addend = rel->r_addend;
3397
3398       switch (r_type)
3399         {
3400         case R_ALPHA_GPDISP:
3401           {
3402             bfd_byte *p_ldah, *p_lda;
3403
3404             BFD_ASSERT(gp != 0);
3405
3406             relocation = (input_section->output_section->vma
3407                           + input_section->output_offset
3408                           + rel->r_offset);
3409
3410             p_ldah = contents + rel->r_offset - input_section->vma;
3411             p_lda = p_ldah + rel->r_addend;
3412
3413             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3414                                              p_ldah, p_lda);
3415           }
3416           break;
3417
3418         case R_ALPHA_LITERAL:
3419           {
3420             struct alpha_elf_got_entry *gotent;
3421             boolean dynamic_symbol;
3422
3423             BFD_ASSERT(sgot != NULL);
3424             BFD_ASSERT(gp != 0);
3425
3426             if (h != NULL)
3427               {
3428                 gotent = h->got_entries;
3429                 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3430               }
3431             else
3432               {
3433                 gotent = (alpha_elf_tdata(input_bfd)->
3434                           local_got_entries[r_symndx]);
3435                 dynamic_symbol = false;
3436               }
3437
3438             BFD_ASSERT(gotent != NULL);
3439
3440             while (gotent->gotobj != gotobj || gotent->addend != addend)
3441               gotent = gotent->next;
3442
3443             BFD_ASSERT(gotent->use_count >= 1);
3444
3445             /* Initialize the .got entry's value.  */
3446             if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3447               {
3448                 bfd_put_64 (output_bfd, relocation+addend,
3449                             sgot->contents + gotent->got_offset);
3450
3451                 /* If the symbol has been forced local, output a
3452                    RELATIVE reloc, otherwise it will be handled in
3453                    finish_dynamic_symbol.  */
3454                 if (info->shared && !dynamic_symbol)
3455                   {
3456                     Elf_Internal_Rela outrel;
3457
3458                     BFD_ASSERT(srelgot != NULL);
3459
3460                     outrel.r_offset = (sgot->output_section->vma
3461                                        + sgot->output_offset
3462                                        + gotent->got_offset);
3463                     outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3464                     outrel.r_addend = relocation+addend;
3465
3466                     bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3467                                                ((Elf64_External_Rela *)
3468                                                 srelgot->contents)
3469                                                + srelgot->reloc_count++);
3470                     BFD_ASSERT (sizeof (Elf64_External_Rela)
3471                                 * srelgot->reloc_count
3472                                 <= srelgot->_cooked_size);
3473                   }
3474
3475                 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3476               }
3477
3478             /* Figure the gprel relocation.  */
3479             addend = 0;
3480             relocation = (sgot->output_section->vma
3481                           + sgot->output_offset
3482                           + gotent->got_offset);
3483             relocation -= gp;
3484           }
3485           /* overflow handled by _bfd_final_link_relocate */
3486           goto default_reloc;
3487
3488         case R_ALPHA_GPREL16:
3489         case R_ALPHA_GPREL32:
3490         case R_ALPHA_GPRELLOW:
3491           BFD_ASSERT(gp != 0);
3492           relocation -= gp;
3493           goto default_reloc;
3494
3495         case R_ALPHA_GPRELHIGH:
3496           BFD_ASSERT(gp != 0);
3497           relocation -= gp;
3498           relocation += addend;
3499           addend = 0;
3500           relocation = (((bfd_signed_vma) relocation >> 16)
3501                         + ((relocation >> 15) & 1));
3502           goto default_reloc;
3503
3504         case R_ALPHA_BRADDR:
3505         case R_ALPHA_HINT:
3506           /* The regular PC-relative stuff measures from the start of
3507              the instruction rather than the end.  */
3508           addend -= 4;
3509           goto default_reloc;
3510
3511         case R_ALPHA_REFLONG:
3512         case R_ALPHA_REFQUAD:
3513           {
3514             Elf_Internal_Rela outrel;
3515             boolean skip;
3516
3517             /* Careful here to remember RELATIVE relocations for global
3518                variables for symbolic shared objects.  */
3519
3520             if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3521               {
3522                 BFD_ASSERT(h->root.dynindx != -1);
3523                 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3524                 outrel.r_addend = addend;
3525                 addend = 0, relocation = 0;
3526               }
3527             else if (info->shared && (input_section->flags & SEC_ALLOC))
3528               {
3529                 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3530                 outrel.r_addend = relocation + addend;
3531               }
3532             else
3533               goto default_reloc;
3534
3535             if (!srel)
3536               {
3537                 const char *name;
3538
3539                 name = (bfd_elf_string_from_elf_section
3540                         (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3541                          elf_section_data(input_section)->rel_hdr.sh_name));
3542                 BFD_ASSERT(name != NULL);
3543
3544                 srel = bfd_get_section_by_name (dynobj, name);
3545                 BFD_ASSERT(srel != NULL);
3546               }
3547
3548             skip = false;
3549
3550             if (elf_section_data (input_section)->stab_info == NULL)
3551               outrel.r_offset = rel->r_offset;
3552             else
3553               {
3554                 bfd_vma off;
3555
3556                 off = (_bfd_stab_section_offset
3557                        (output_bfd, &elf_hash_table (info)->stab_info,
3558                         input_section,
3559                         &elf_section_data (input_section)->stab_info,
3560                         rel->r_offset));
3561                 if (off == (bfd_vma) -1)
3562                   skip = true;
3563                 outrel.r_offset = off;
3564               }
3565
3566             if (! skip)
3567               outrel.r_offset += (input_section->output_section->vma
3568                                   + input_section->output_offset);
3569             else
3570               memset (&outrel, 0, sizeof outrel);
3571
3572             bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3573                                        ((Elf64_External_Rela *)
3574                                         srel->contents)
3575                                        + srel->reloc_count++);
3576             BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3577                         <= srel->_cooked_size);
3578           }
3579           goto default_reloc;
3580
3581         default:
3582         default_reloc:
3583           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3584                                         contents, rel->r_offset, relocation,
3585                                         addend);
3586           break;
3587         }
3588
3589       switch (r)
3590         {
3591         case bfd_reloc_ok:
3592           break;
3593
3594         case bfd_reloc_overflow:
3595           {
3596             const char *name;
3597
3598             if (h != NULL)
3599               name = h->root.root.root.string;
3600             else
3601               {
3602                 name = (bfd_elf_string_from_elf_section
3603                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
3604                 if (name == NULL)
3605                   return false;
3606                 if (*name == '\0')
3607                   name = bfd_section_name (input_bfd, sec);
3608               }
3609             if (! ((*info->callbacks->reloc_overflow)
3610                    (info, name, howto->name, (bfd_vma) 0,
3611                     input_bfd, input_section, rel->r_offset)))
3612               return false;
3613           }
3614           break;
3615
3616         default:
3617         case bfd_reloc_outofrange:
3618           abort ();
3619         }
3620     }
3621
3622   return true;
3623 }
3624
3625 /* Finish up dynamic symbol handling.  We set the contents of various
3626    dynamic sections here.  */
3627
3628 static boolean
3629 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3630      bfd *output_bfd;
3631      struct bfd_link_info *info;
3632      struct elf_link_hash_entry *h;
3633      Elf_Internal_Sym *sym;
3634 {
3635   bfd *dynobj = elf_hash_table(info)->dynobj;
3636
3637   if (h->plt.offset != MINUS_ONE)
3638     {
3639       /* Fill in the .plt entry for this symbol.  */
3640       asection *splt, *sgot, *srel;
3641       Elf_Internal_Rela outrel;
3642       bfd_vma got_addr, plt_addr;
3643       bfd_vma plt_index;
3644       struct alpha_elf_got_entry *gotent;
3645
3646       BFD_ASSERT (h->dynindx != -1);
3647
3648       /* The first .got entry will be updated by the .plt with the
3649          address of the target function.  */
3650       gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3651       BFD_ASSERT (gotent && gotent->addend == 0);
3652
3653       splt = bfd_get_section_by_name (dynobj, ".plt");
3654       BFD_ASSERT (splt != NULL);
3655       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3656       BFD_ASSERT (srel != NULL);
3657       sgot = alpha_elf_tdata (gotent->gotobj)->got;
3658       BFD_ASSERT (sgot != NULL);
3659
3660       got_addr = (sgot->output_section->vma
3661                   + sgot->output_offset
3662                   + gotent->got_offset);
3663       plt_addr = (splt->output_section->vma
3664                   + splt->output_offset
3665                   + h->plt.offset);
3666
3667       plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3668
3669       /* Fill in the entry in the procedure linkage table.  */
3670       {
3671         unsigned insn1, insn2, insn3;
3672
3673         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3674         insn2 = PLT_ENTRY_WORD2;
3675         insn3 = PLT_ENTRY_WORD3;
3676
3677         bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3678         bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3679         bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3680       }
3681
3682       /* Fill in the entry in the .rela.plt section.  */
3683       outrel.r_offset = got_addr;
3684       outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3685       outrel.r_addend = 0;
3686
3687       bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3688                                  ((Elf64_External_Rela *)srel->contents
3689                                   + plt_index));
3690
3691       if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3692         {
3693           /* Mark the symbol as undefined, rather than as defined in the
3694              .plt section.  Leave the value alone.  */
3695           sym->st_shndx = SHN_UNDEF;
3696         }
3697
3698       /* Fill in the entries in the .got.  */
3699       bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3700
3701       /* Subsequent .got entries will continue to bounce through the .plt.  */
3702       if (gotent->next)
3703         {
3704           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3705           BFD_ASSERT (! info->shared || srel != NULL);
3706
3707           gotent = gotent->next;
3708           do
3709             {
3710               sgot = alpha_elf_tdata(gotent->gotobj)->got;
3711               BFD_ASSERT(sgot != NULL);
3712               BFD_ASSERT(gotent->addend == 0);
3713
3714               bfd_put_64 (output_bfd, plt_addr,
3715                           sgot->contents + gotent->got_offset);
3716
3717               if (info->shared)
3718                 {
3719                   outrel.r_offset = (sgot->output_section->vma
3720                                      + sgot->output_offset
3721                                      + gotent->got_offset);
3722                   outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3723                   outrel.r_addend = plt_addr;
3724
3725                   bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3726                                              ((Elf64_External_Rela *)
3727                                               srel->contents)
3728                                              + srel->reloc_count++);
3729                   BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3730                               <= srel->_cooked_size);
3731                 }
3732
3733               gotent = gotent->next;
3734             }
3735           while (gotent != NULL);
3736         }
3737     }
3738   else if (alpha_elf_dynamic_symbol_p (h, info))
3739     {
3740       /* Fill in the dynamic relocations for this symbol's .got entries.  */
3741       asection *srel;
3742       Elf_Internal_Rela outrel;
3743       struct alpha_elf_got_entry *gotent;
3744
3745       srel = bfd_get_section_by_name (dynobj, ".rela.got");
3746       BFD_ASSERT (srel != NULL);
3747
3748       outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3749       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3750            gotent != NULL;
3751            gotent = gotent->next)
3752         {
3753           asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3754           outrel.r_offset = (sgot->output_section->vma
3755                              + sgot->output_offset
3756                              + gotent->got_offset);
3757           outrel.r_addend = gotent->addend;
3758
3759           bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3760                                      ((Elf64_External_Rela *)srel->contents
3761                                       + srel->reloc_count++));
3762           BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3763                       <= srel->_cooked_size);
3764         }
3765     }
3766
3767   /* Mark some specially defined symbols as absolute.  */
3768   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3769       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3770       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3771     sym->st_shndx = SHN_ABS;
3772
3773   return true;
3774 }
3775
3776 /* Finish up the dynamic sections.  */
3777
3778 static boolean
3779 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3780      bfd *output_bfd;
3781      struct bfd_link_info *info;
3782 {
3783   bfd *dynobj;
3784   asection *sdyn;
3785
3786   dynobj = elf_hash_table (info)->dynobj;
3787   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3788
3789   if (elf_hash_table (info)->dynamic_sections_created)
3790     {
3791       asection *splt;
3792       Elf64_External_Dyn *dyncon, *dynconend;
3793
3794       splt = bfd_get_section_by_name (dynobj, ".plt");
3795       BFD_ASSERT (splt != NULL && sdyn != NULL);
3796
3797       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3798       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3799       for (; dyncon < dynconend; dyncon++)
3800         {
3801           Elf_Internal_Dyn dyn;
3802           const char *name;
3803           asection *s;
3804
3805           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3806
3807           switch (dyn.d_tag)
3808             {
3809             case DT_PLTGOT:
3810               name = ".plt";
3811               goto get_vma;
3812             case DT_PLTRELSZ:
3813               name = ".rela.plt";
3814               goto get_size;
3815             case DT_JMPREL:
3816               name = ".rela.plt";
3817               goto get_vma;
3818
3819             case DT_RELASZ:
3820               /* My interpretation of the TIS v1.1 ELF document indicates
3821                  that RELASZ should not include JMPREL.  This is not what
3822                  the rest of the BFD does.  It is, however, what the
3823                  glibc ld.so wants.  Do this fixup here until we found
3824                  out who is right.  */
3825               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3826               if (s)
3827                 {
3828                   dyn.d_un.d_val -=
3829                     (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3830                 }
3831               break;
3832
3833             get_vma:
3834               s = bfd_get_section_by_name (output_bfd, name);
3835               dyn.d_un.d_ptr = (s ? s->vma : 0);
3836               break;
3837
3838             get_size:
3839               s = bfd_get_section_by_name (output_bfd, name);
3840               dyn.d_un.d_val =
3841                 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3842               break;
3843             }
3844
3845           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3846         }
3847
3848       /* Initialize the PLT0 entry */
3849       if (splt->_raw_size > 0)
3850         {
3851           bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3852           bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3853           bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3854           bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3855
3856           /* The next two words will be filled in by ld.so */
3857           bfd_put_64 (output_bfd, 0, splt->contents + 16);
3858           bfd_put_64 (output_bfd, 0, splt->contents + 24);
3859
3860           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3861             PLT_HEADER_SIZE;
3862         }
3863     }
3864
3865   return true;
3866 }
3867
3868 /* We need to use a special link routine to handle the .reginfo and
3869    the .mdebug sections.  We need to merge all instances of these
3870    sections together, not write them all out sequentially.  */
3871
3872 static boolean
3873 elf64_alpha_final_link (abfd, info)
3874      bfd *abfd;
3875      struct bfd_link_info *info;
3876 {
3877   asection *o;
3878   struct bfd_link_order *p;
3879   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3880   struct ecoff_debug_info debug;
3881   const struct ecoff_debug_swap *swap
3882     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3883   HDRR *symhdr = &debug.symbolic_header;
3884   PTR mdebug_handle = NULL;
3885
3886 #if 0
3887               if (++ngots == 2)
3888                 {
3889                   (*info->callbacks->warning)
3890                     (info, _("using multiple gp values"), (char *) NULL,
3891                      output_bfd, (asection *) NULL, (bfd_vma) 0);
3892                 }
3893 #endif
3894
3895   /* Go through the sections and collect the .reginfo and .mdebug
3896      information.  */
3897   reginfo_sec = NULL;
3898   mdebug_sec = NULL;
3899   gptab_data_sec = NULL;
3900   gptab_bss_sec = NULL;
3901   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3902     {
3903 #ifdef ERIC_neverdef
3904       if (strcmp (o->name, ".reginfo") == 0)
3905         {
3906           memset (&reginfo, 0, sizeof reginfo);
3907
3908           /* We have found the .reginfo section in the output file.
3909              Look through all the link_orders comprising it and merge
3910              the information together.  */
3911           for (p = o->link_order_head;
3912                p != (struct bfd_link_order *) NULL;
3913                p = p->next)
3914             {
3915               asection *input_section;
3916               bfd *input_bfd;
3917               Elf64_External_RegInfo ext;
3918               Elf64_RegInfo sub;
3919
3920               if (p->type != bfd_indirect_link_order)
3921                 {
3922                   if (p->type == bfd_fill_link_order)
3923                     continue;
3924                   abort ();
3925                 }
3926
3927               input_section = p->u.indirect.section;
3928               input_bfd = input_section->owner;
3929
3930               /* The linker emulation code has probably clobbered the
3931                  size to be zero bytes.  */
3932               if (input_section->_raw_size == 0)
3933                 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
3934
3935               if (! bfd_get_section_contents (input_bfd, input_section,
3936                                               (PTR) &ext,
3937                                               (file_ptr) 0,
3938                                               sizeof ext))
3939                 return false;
3940
3941               bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
3942
3943               reginfo.ri_gprmask |= sub.ri_gprmask;
3944               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
3945               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
3946               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
3947               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
3948
3949               /* ri_gp_value is set by the function
3950                  alpha_elf_section_processing when the section is
3951                  finally written out.  */
3952
3953               /* Hack: reset the SEC_HAS_CONTENTS flag so that
3954                  elf_link_input_bfd ignores this section.  */
3955               input_section->flags &=~ SEC_HAS_CONTENTS;
3956             }
3957
3958           /* Force the section size to the value we want.  */
3959           o->_raw_size = sizeof (Elf64_External_RegInfo);
3960
3961           /* Skip this section later on (I don't think this currently
3962              matters, but someday it might).  */
3963           o->link_order_head = (struct bfd_link_order *) NULL;
3964
3965           reginfo_sec = o;
3966         }
3967 #endif
3968
3969       if (strcmp (o->name, ".mdebug") == 0)
3970         {
3971           struct extsym_info einfo;
3972
3973           /* We have found the .mdebug section in the output file.
3974              Look through all the link_orders comprising it and merge
3975              the information together.  */
3976           symhdr->magic = swap->sym_magic;
3977           /* FIXME: What should the version stamp be?  */
3978           symhdr->vstamp = 0;
3979           symhdr->ilineMax = 0;
3980           symhdr->cbLine = 0;
3981           symhdr->idnMax = 0;
3982           symhdr->ipdMax = 0;
3983           symhdr->isymMax = 0;
3984           symhdr->ioptMax = 0;
3985           symhdr->iauxMax = 0;
3986           symhdr->issMax = 0;
3987           symhdr->issExtMax = 0;
3988           symhdr->ifdMax = 0;
3989           symhdr->crfd = 0;
3990           symhdr->iextMax = 0;
3991
3992           /* We accumulate the debugging information itself in the
3993              debug_info structure.  */
3994           debug.line = NULL;
3995           debug.external_dnr = NULL;
3996           debug.external_pdr = NULL;
3997           debug.external_sym = NULL;
3998           debug.external_opt = NULL;
3999           debug.external_aux = NULL;
4000           debug.ss = NULL;
4001           debug.ssext = debug.ssext_end = NULL;
4002           debug.external_fdr = NULL;
4003           debug.external_rfd = NULL;
4004           debug.external_ext = debug.external_ext_end = NULL;
4005
4006           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4007           if (mdebug_handle == (PTR) NULL)
4008             return false;
4009
4010           if (1)
4011             {
4012               asection *s;
4013               EXTR esym;
4014               bfd_vma last = 0;
4015               unsigned int i;
4016               static const char * const name[] =
4017                 {
4018                   ".text", ".init", ".fini", ".data",
4019                   ".rodata", ".sdata", ".sbss", ".bss"
4020                 };
4021               static const int sc[] = { scText, scInit, scFini, scData,
4022                                           scRData, scSData, scSBss, scBss };
4023
4024               esym.jmptbl = 0;
4025               esym.cobol_main = 0;
4026               esym.weakext = 0;
4027               esym.reserved = 0;
4028               esym.ifd = ifdNil;
4029               esym.asym.iss = issNil;
4030               esym.asym.st = stLocal;
4031               esym.asym.reserved = 0;
4032               esym.asym.index = indexNil;
4033               for (i = 0; i < 8; i++)
4034                 {
4035                   esym.asym.sc = sc[i];
4036                   s = bfd_get_section_by_name (abfd, name[i]);
4037                   if (s != NULL)
4038                     {
4039                       esym.asym.value = s->vma;
4040                       last = s->vma + s->_raw_size;
4041                     }
4042                   else
4043                     esym.asym.value = last;
4044
4045                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4046                                                       name[i], &esym))
4047                     return false;
4048                 }
4049             }
4050
4051           for (p = o->link_order_head;
4052                p != (struct bfd_link_order *) NULL;
4053                p = p->next)
4054             {
4055               asection *input_section;
4056               bfd *input_bfd;
4057               const struct ecoff_debug_swap *input_swap;
4058               struct ecoff_debug_info input_debug;
4059               char *eraw_src;
4060               char *eraw_end;
4061
4062               if (p->type != bfd_indirect_link_order)
4063                 {
4064                   if (p->type == bfd_fill_link_order)
4065                     continue;
4066                   abort ();
4067                 }
4068
4069               input_section = p->u.indirect.section;
4070               input_bfd = input_section->owner;
4071
4072               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4073                   || (get_elf_backend_data (input_bfd)
4074                       ->elf_backend_ecoff_debug_swap) == NULL)
4075                 {
4076                   /* I don't know what a non ALPHA ELF bfd would be
4077                      doing with a .mdebug section, but I don't really
4078                      want to deal with it.  */
4079                   continue;
4080                 }
4081
4082               input_swap = (get_elf_backend_data (input_bfd)
4083                             ->elf_backend_ecoff_debug_swap);
4084
4085               BFD_ASSERT (p->size == input_section->_raw_size);
4086
4087               /* The ECOFF linking code expects that we have already
4088                  read in the debugging information and set up an
4089                  ecoff_debug_info structure, so we do that now.  */
4090               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4091                                                 &input_debug))
4092                 return false;
4093
4094               if (! (bfd_ecoff_debug_accumulate
4095                      (mdebug_handle, abfd, &debug, swap, input_bfd,
4096                       &input_debug, input_swap, info)))
4097                 return false;
4098
4099               /* Loop through the external symbols.  For each one with
4100                  interesting information, try to find the symbol in
4101                  the linker global hash table and save the information
4102                  for the output external symbols.  */
4103               eraw_src = input_debug.external_ext;
4104               eraw_end = (eraw_src
4105                           + (input_debug.symbolic_header.iextMax
4106                              * input_swap->external_ext_size));
4107               for (;
4108                    eraw_src < eraw_end;
4109                    eraw_src += input_swap->external_ext_size)
4110                 {
4111                   EXTR ext;
4112                   const char *name;
4113                   struct alpha_elf_link_hash_entry *h;
4114
4115                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4116                   if (ext.asym.sc == scNil
4117                       || ext.asym.sc == scUndefined
4118                       || ext.asym.sc == scSUndefined)
4119                     continue;
4120
4121                   name = input_debug.ssext + ext.asym.iss;
4122                   h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4123                                                   name, false, false, true);
4124                   if (h == NULL || h->esym.ifd != -2)
4125                     continue;
4126
4127                   if (ext.ifd != -1)
4128                     {
4129                       BFD_ASSERT (ext.ifd
4130                                   < input_debug.symbolic_header.ifdMax);
4131                       ext.ifd = input_debug.ifdmap[ext.ifd];
4132                     }
4133
4134                   h->esym = ext;
4135                 }
4136
4137               /* Free up the information we just read.  */
4138               free (input_debug.line);
4139               free (input_debug.external_dnr);
4140               free (input_debug.external_pdr);
4141               free (input_debug.external_sym);
4142               free (input_debug.external_opt);
4143               free (input_debug.external_aux);
4144               free (input_debug.ss);
4145               free (input_debug.ssext);
4146               free (input_debug.external_fdr);
4147               free (input_debug.external_rfd);
4148               free (input_debug.external_ext);
4149
4150               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4151                  elf_link_input_bfd ignores this section.  */
4152               input_section->flags &=~ SEC_HAS_CONTENTS;
4153             }
4154
4155 #ifdef ERIC_neverdef
4156           if (info->shared)
4157             {
4158               /* Create .rtproc section.  */
4159               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4160               if (rtproc_sec == NULL)
4161                 {
4162                   flagword flags = (SEC_HAS_CONTENTS
4163                                     | SEC_IN_MEMORY
4164                                     | SEC_LINKER_CREATED
4165                                     | SEC_READONLY);
4166
4167                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
4168                   if (rtproc_sec == NULL
4169                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4170                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4171                     return false;
4172                 }
4173
4174               if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4175                                                      info, rtproc_sec, &debug))
4176                 return false;
4177             }
4178 #endif
4179
4180           /* Build the external symbol information.  */
4181           einfo.abfd = abfd;
4182           einfo.info = info;
4183           einfo.debug = &debug;
4184           einfo.swap = swap;
4185           einfo.failed = false;
4186           elf_link_hash_traverse (elf_hash_table (info),
4187                                   elf64_alpha_output_extsym,
4188                                   (PTR) &einfo);
4189           if (einfo.failed)
4190             return false;
4191
4192           /* Set the size of the .mdebug section.  */
4193           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4194
4195           /* Skip this section later on (I don't think this currently
4196              matters, but someday it might).  */
4197           o->link_order_head = (struct bfd_link_order *) NULL;
4198
4199           mdebug_sec = o;
4200         }
4201
4202 #ifdef ERIC_neverdef
4203       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4204         {
4205           const char *subname;
4206           unsigned int c;
4207           Elf64_gptab *tab;
4208           Elf64_External_gptab *ext_tab;
4209           unsigned int i;
4210
4211           /* The .gptab.sdata and .gptab.sbss sections hold
4212              information describing how the small data area would
4213              change depending upon the -G switch.  These sections
4214              not used in executables files.  */
4215           if (! info->relocateable)
4216             {
4217               asection **secpp;
4218
4219               for (p = o->link_order_head;
4220                    p != (struct bfd_link_order *) NULL;
4221                    p = p->next)
4222                 {
4223                   asection *input_section;
4224
4225                   if (p->type != bfd_indirect_link_order)
4226                     {
4227                       if (p->type == bfd_fill_link_order)
4228                         continue;
4229                       abort ();
4230                     }
4231
4232                   input_section = p->u.indirect.section;
4233
4234                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
4235                      elf_link_input_bfd ignores this section.  */
4236                   input_section->flags &=~ SEC_HAS_CONTENTS;
4237                 }
4238
4239               /* Skip this section later on (I don't think this
4240                  currently matters, but someday it might).  */
4241               o->link_order_head = (struct bfd_link_order *) NULL;
4242
4243               /* Really remove the section.  */
4244               for (secpp = &abfd->sections;
4245                    *secpp != o;
4246                    secpp = &(*secpp)->next)
4247                 ;
4248               *secpp = (*secpp)->next;
4249               --abfd->section_count;
4250
4251               continue;
4252             }
4253
4254           /* There is one gptab for initialized data, and one for
4255              uninitialized data.  */
4256           if (strcmp (o->name, ".gptab.sdata") == 0)
4257             gptab_data_sec = o;
4258           else if (strcmp (o->name, ".gptab.sbss") == 0)
4259             gptab_bss_sec = o;
4260           else
4261             {
4262               (*_bfd_error_handler)
4263                 (_("%s: illegal section name `%s'"),
4264                  bfd_get_filename (abfd), o->name);
4265               bfd_set_error (bfd_error_nonrepresentable_section);
4266               return false;
4267             }
4268
4269           /* The linker script always combines .gptab.data and
4270              .gptab.sdata into .gptab.sdata, and likewise for
4271              .gptab.bss and .gptab.sbss.  It is possible that there is
4272              no .sdata or .sbss section in the output file, in which
4273              case we must change the name of the output section.  */
4274           subname = o->name + sizeof ".gptab" - 1;
4275           if (bfd_get_section_by_name (abfd, subname) == NULL)
4276             {
4277               if (o == gptab_data_sec)
4278                 o->name = ".gptab.data";
4279               else
4280                 o->name = ".gptab.bss";
4281               subname = o->name + sizeof ".gptab" - 1;
4282               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4283             }
4284
4285           /* Set up the first entry.  */
4286           c = 1;
4287           tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4288           if (tab == NULL)
4289             return false;
4290           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4291           tab[0].gt_header.gt_unused = 0;
4292
4293           /* Combine the input sections.  */
4294           for (p = o->link_order_head;
4295                p != (struct bfd_link_order *) NULL;
4296                p = p->next)
4297             {
4298               asection *input_section;
4299               bfd *input_bfd;
4300               bfd_size_type size;
4301               unsigned long last;
4302               bfd_size_type gpentry;
4303
4304               if (p->type != bfd_indirect_link_order)
4305                 {
4306                   if (p->type == bfd_fill_link_order)
4307                     continue;
4308                   abort ();
4309                 }
4310
4311               input_section = p->u.indirect.section;
4312               input_bfd = input_section->owner;
4313
4314               /* Combine the gptab entries for this input section one
4315                  by one.  We know that the input gptab entries are
4316                  sorted by ascending -G value.  */
4317               size = bfd_section_size (input_bfd, input_section);
4318               last = 0;
4319               for (gpentry = sizeof (Elf64_External_gptab);
4320                    gpentry < size;
4321                    gpentry += sizeof (Elf64_External_gptab))
4322                 {
4323                   Elf64_External_gptab ext_gptab;
4324                   Elf64_gptab int_gptab;
4325                   unsigned long val;
4326                   unsigned long add;
4327                   boolean exact;
4328                   unsigned int look;
4329
4330                   if (! (bfd_get_section_contents
4331                          (input_bfd, input_section, (PTR) &ext_gptab,
4332                           gpentry, sizeof (Elf64_External_gptab))))
4333                     {
4334                       free (tab);
4335                       return false;
4336                     }
4337
4338                   bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4339                                                 &int_gptab);
4340                   val = int_gptab.gt_entry.gt_g_value;
4341                   add = int_gptab.gt_entry.gt_bytes - last;
4342
4343                   exact = false;
4344                   for (look = 1; look < c; look++)
4345                     {
4346                       if (tab[look].gt_entry.gt_g_value >= val)
4347                         tab[look].gt_entry.gt_bytes += add;
4348
4349                       if (tab[look].gt_entry.gt_g_value == val)
4350                         exact = true;
4351                     }
4352
4353                   if (! exact)
4354                     {
4355                       Elf64_gptab *new_tab;
4356                       unsigned int max;
4357
4358                       /* We need a new table entry.  */
4359                       new_tab = ((Elf64_gptab *)
4360                                  bfd_realloc ((PTR) tab,
4361                                               (c + 1) * sizeof (Elf64_gptab)));
4362                       if (new_tab == NULL)
4363                         {
4364                           free (tab);
4365                           return false;
4366                         }
4367                       tab = new_tab;
4368                       tab[c].gt_entry.gt_g_value = val;
4369                       tab[c].gt_entry.gt_bytes = add;
4370
4371                       /* Merge in the size for the next smallest -G
4372                          value, since that will be implied by this new
4373                          value.  */
4374                       max = 0;
4375                       for (look = 1; look < c; look++)
4376                         {
4377                           if (tab[look].gt_entry.gt_g_value < val
4378                               && (max == 0
4379                                   || (tab[look].gt_entry.gt_g_value
4380                                       > tab[max].gt_entry.gt_g_value)))
4381                             max = look;
4382                         }
4383                       if (max != 0)
4384                         tab[c].gt_entry.gt_bytes +=
4385                           tab[max].gt_entry.gt_bytes;
4386
4387                       ++c;
4388                     }
4389
4390                   last = int_gptab.gt_entry.gt_bytes;
4391                 }
4392
4393               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4394                  elf_link_input_bfd ignores this section.  */
4395               input_section->flags &=~ SEC_HAS_CONTENTS;
4396             }
4397
4398           /* The table must be sorted by -G value.  */
4399           if (c > 2)
4400             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4401
4402           /* Swap out the table.  */
4403           ext_tab = ((Elf64_External_gptab *)
4404                      bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4405           if (ext_tab == NULL)
4406             {
4407               free (tab);
4408               return false;
4409             }
4410
4411           for (i = 0; i < c; i++)
4412             bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4413           free (tab);
4414
4415           o->_raw_size = c * sizeof (Elf64_External_gptab);
4416           o->contents = (bfd_byte *) ext_tab;
4417
4418           /* Skip this section later on (I don't think this currently
4419              matters, but someday it might).  */
4420           o->link_order_head = (struct bfd_link_order *) NULL;
4421         }
4422 #endif
4423
4424     }
4425
4426   /* Invoke the regular ELF backend linker to do all the work.  */
4427   if (! bfd_elf64_bfd_final_link (abfd, info))
4428     return false;
4429
4430   /* Now write out the computed sections.  */
4431
4432   /* The .got subsections...  */
4433   {
4434     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4435     for (i = alpha_elf_hash_table(info)->got_list;
4436          i != NULL;
4437          i = alpha_elf_tdata(i)->got_link_next)
4438       {
4439         asection *sgot;
4440
4441         /* elf_bfd_final_link already did everything in dynobj.  */
4442         if (i == dynobj)
4443           continue;
4444
4445         sgot = alpha_elf_tdata(i)->got;
4446         if (! bfd_set_section_contents (abfd, sgot->output_section,
4447                                         sgot->contents, sgot->output_offset,
4448                                         sgot->_raw_size))
4449           return false;
4450       }
4451   }
4452
4453 #ifdef ERIC_neverdef
4454   if (reginfo_sec != (asection *) NULL)
4455     {
4456       Elf64_External_RegInfo ext;
4457
4458       bfd_alpha_elf64_swap_reginfo_out (abfd, &reginfo, &ext);
4459       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4460                                       (file_ptr) 0, sizeof ext))
4461         return false;
4462     }
4463 #endif
4464
4465   if (mdebug_sec != (asection *) NULL)
4466     {
4467       BFD_ASSERT (abfd->output_has_begun);
4468       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4469                                                swap, info,
4470                                                mdebug_sec->filepos))
4471         return false;
4472
4473       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4474     }
4475
4476   if (gptab_data_sec != (asection *) NULL)
4477     {
4478       if (! bfd_set_section_contents (abfd, gptab_data_sec,
4479                                       gptab_data_sec->contents,
4480                                       (file_ptr) 0,
4481                                       gptab_data_sec->_raw_size))
4482         return false;
4483     }
4484
4485   if (gptab_bss_sec != (asection *) NULL)
4486     {
4487       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4488                                       gptab_bss_sec->contents,
4489                                       (file_ptr) 0,
4490                                       gptab_bss_sec->_raw_size))
4491         return false;
4492     }
4493
4494   return true;
4495 }
4496
4497 static enum elf_reloc_type_class
4498 elf64_alpha_reloc_type_class (type)
4499      int type;
4500 {
4501   switch (type)
4502     {
4503     case R_ALPHA_RELATIVE:
4504       return reloc_class_relative;
4505     case R_ALPHA_JMP_SLOT:
4506       return reloc_class_plt;
4507     case R_ALPHA_COPY:
4508       return reloc_class_copy;
4509     default:
4510       return reloc_class_normal;
4511     }
4512 }
4513 \f
4514 /* ECOFF swapping routines.  These are used when dealing with the
4515    .mdebug section, which is in the ECOFF debugging format.  Copied
4516    from elf32-mips.c.  */
4517 static const struct ecoff_debug_swap
4518 elf64_alpha_ecoff_debug_swap =
4519 {
4520   /* Symbol table magic number.  */
4521   magicSym2,
4522   /* Alignment of debugging information.  E.g., 4.  */
4523   8,
4524   /* Sizes of external symbolic information.  */
4525   sizeof (struct hdr_ext),
4526   sizeof (struct dnr_ext),
4527   sizeof (struct pdr_ext),
4528   sizeof (struct sym_ext),
4529   sizeof (struct opt_ext),
4530   sizeof (struct fdr_ext),
4531   sizeof (struct rfd_ext),
4532   sizeof (struct ext_ext),
4533   /* Functions to swap in external symbolic data.  */
4534   ecoff_swap_hdr_in,
4535   ecoff_swap_dnr_in,
4536   ecoff_swap_pdr_in,
4537   ecoff_swap_sym_in,
4538   ecoff_swap_opt_in,
4539   ecoff_swap_fdr_in,
4540   ecoff_swap_rfd_in,
4541   ecoff_swap_ext_in,
4542   _bfd_ecoff_swap_tir_in,
4543   _bfd_ecoff_swap_rndx_in,
4544   /* Functions to swap out external symbolic data.  */
4545   ecoff_swap_hdr_out,
4546   ecoff_swap_dnr_out,
4547   ecoff_swap_pdr_out,
4548   ecoff_swap_sym_out,
4549   ecoff_swap_opt_out,
4550   ecoff_swap_fdr_out,
4551   ecoff_swap_rfd_out,
4552   ecoff_swap_ext_out,
4553   _bfd_ecoff_swap_tir_out,
4554   _bfd_ecoff_swap_rndx_out,
4555   /* Function to read in symbolic data.  */
4556   elf64_alpha_read_ecoff_info
4557 };
4558 \f
4559 /* Use a non-standard hash bucket size of 8.  */
4560
4561 const struct elf_size_info alpha_elf_size_info =
4562 {
4563   sizeof (Elf64_External_Ehdr),
4564   sizeof (Elf64_External_Phdr),
4565   sizeof (Elf64_External_Shdr),
4566   sizeof (Elf64_External_Rel),
4567   sizeof (Elf64_External_Rela),
4568   sizeof (Elf64_External_Sym),
4569   sizeof (Elf64_External_Dyn),
4570   sizeof (Elf_External_Note),
4571   8,
4572   1,
4573   64, 8,
4574   ELFCLASS64, EV_CURRENT,
4575   bfd_elf64_write_out_phdrs,
4576   bfd_elf64_write_shdrs_and_ehdr,
4577   bfd_elf64_write_relocs,
4578   bfd_elf64_swap_symbol_out,
4579   bfd_elf64_slurp_reloc_table,
4580   bfd_elf64_slurp_symbol_table,
4581   bfd_elf64_swap_dyn_in,
4582   bfd_elf64_swap_dyn_out,
4583   NULL,
4584   NULL,
4585   NULL,
4586   NULL
4587 };
4588
4589 #define TARGET_LITTLE_SYM       bfd_elf64_alpha_vec
4590 #define TARGET_LITTLE_NAME      "elf64-alpha"
4591 #define ELF_ARCH                bfd_arch_alpha
4592 #define ELF_MACHINE_CODE        EM_ALPHA
4593 #define ELF_MAXPAGESIZE 0x10000
4594
4595 #define bfd_elf64_bfd_link_hash_table_create \
4596   elf64_alpha_bfd_link_hash_table_create
4597
4598 #define bfd_elf64_bfd_reloc_type_lookup \
4599   elf64_alpha_bfd_reloc_type_lookup
4600 #define elf_info_to_howto \
4601   elf64_alpha_info_to_howto
4602
4603 #define bfd_elf64_mkobject \
4604   elf64_alpha_mkobject
4605 #define elf_backend_object_p \
4606   elf64_alpha_object_p
4607
4608 #define elf_backend_section_from_shdr \
4609   elf64_alpha_section_from_shdr
4610 #define elf_backend_fake_sections \
4611   elf64_alpha_fake_sections
4612
4613 #define bfd_elf64_bfd_is_local_label_name \
4614   elf64_alpha_is_local_label_name
4615 #define bfd_elf64_find_nearest_line \
4616   elf64_alpha_find_nearest_line
4617 #define bfd_elf64_bfd_relax_section \
4618   elf64_alpha_relax_section
4619
4620 #define elf_backend_add_symbol_hook \
4621   elf64_alpha_add_symbol_hook
4622 #define elf_backend_check_relocs \
4623   elf64_alpha_check_relocs
4624 #define elf_backend_create_dynamic_sections \
4625   elf64_alpha_create_dynamic_sections
4626 #define elf_backend_adjust_dynamic_symbol \
4627   elf64_alpha_adjust_dynamic_symbol
4628 #define elf_backend_always_size_sections \
4629   elf64_alpha_always_size_sections
4630 #define elf_backend_size_dynamic_sections \
4631   elf64_alpha_size_dynamic_sections
4632 #define elf_backend_relocate_section \
4633   elf64_alpha_relocate_section
4634 #define elf_backend_finish_dynamic_symbol \
4635   elf64_alpha_finish_dynamic_symbol
4636 #define elf_backend_finish_dynamic_sections \
4637   elf64_alpha_finish_dynamic_sections
4638 #define bfd_elf64_bfd_final_link \
4639   elf64_alpha_final_link
4640 #define elf_backend_reloc_type_class \
4641   elf64_alpha_reloc_type_class
4642
4643 #define elf_backend_ecoff_debug_swap \
4644   &elf64_alpha_ecoff_debug_swap
4645
4646 #define elf_backend_size_info \
4647   alpha_elf_size_info
4648
4649 /* A few constants that determine how the .plt section is set up.  */
4650 #define elf_backend_want_got_plt 0
4651 #define elf_backend_plt_readonly 0
4652 #define elf_backend_want_plt_sym 1
4653 #define elf_backend_got_header_size 0
4654 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4655
4656 #include "elf64-target.h"