bfd/elf64-alpha.c

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