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 && (sec->flags & SEC_ALLOC))
2585             {
2586               /* If this is a shared library, and the section is to be
2587                  loaded into memory, we need a RELATIVE reloc.  */
2588               sreloc->_raw_size += sizeof (Elf64_External_Rela);
2589             }
2590           break;
2591         }
2592     }
2593
2594   return true;
2595 }
2596
2597 /* Adjust a symbol defined by a dynamic object and referenced by a
2598    regular object.  The current definition is in some section of the
2599    dynamic object, but we're not including those sections.  We have to
2600    change the definition to something the rest of the link can
2601    understand.  */
2602
2603 static boolean
2604 elf64_alpha_adjust_dynamic_symbol (info, h)
2605      struct bfd_link_info *info;
2606      struct elf_link_hash_entry *h;
2607 {
2608   bfd *dynobj;
2609   asection *s;
2610   struct alpha_elf_link_hash_entry *ah;
2611
2612   dynobj = elf_hash_table(info)->dynobj;
2613   ah = (struct alpha_elf_link_hash_entry *)h;
2614
2615   /* Now that we've seen all of the input symbols, finalize our decision
2616      about whether this symbol should get a .plt entry.  */
2617
2618   if (h->root.type != bfd_link_hash_undefweak
2619       && alpha_elf_dynamic_symbol_p (h, info)
2620       && ((h->type == STT_FUNC
2621            && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2622           || (h->type == STT_NOTYPE
2623               && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2624       /* Don't prevent otherwise valid programs from linking by attempting
2625          to create a new .got entry somewhere.  A Correct Solution would be
2626          to add a new .got section to a new object file and let it be merged
2627          somewhere later.  But for now don't bother.  */
2628       && ah->got_entries)
2629     {
2630       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2631
2632       s = bfd_get_section_by_name(dynobj, ".plt");
2633       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2634         return false;
2635
2636       /* The first bit of the .plt is reserved.  */
2637       if (s->_raw_size == 0)
2638         s->_raw_size = PLT_HEADER_SIZE;
2639
2640       h->plt.offset = s->_raw_size;
2641       s->_raw_size += PLT_ENTRY_SIZE;
2642
2643       /* If this symbol is not defined in a regular file, and we are not
2644          generating a shared library, then set the symbol to the location
2645          in the .plt.  This is required to make function pointers compare
2646          equal between the normal executable and the shared library.  */
2647       if (! info->shared
2648           && h->root.type != bfd_link_hash_defweak)
2649         {
2650           h->root.u.def.section = s;
2651           h->root.u.def.value = h->plt.offset;
2652         }
2653
2654       /* We also need a JMP_SLOT entry in the .rela.plt section.  */
2655       s = bfd_get_section_by_name (dynobj, ".rela.plt");
2656       BFD_ASSERT (s != NULL);
2657       s->_raw_size += sizeof (Elf64_External_Rela);
2658
2659       return true;
2660     }
2661   else
2662     h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2663
2664   /* If this is a weak symbol, and there is a real definition, the
2665      processor independent code will have arranged for us to see the
2666      real definition first, and we can just use the same value.  */
2667   if (h->weakdef != NULL)
2668     {
2669       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2670                   || h->weakdef->root.type == bfd_link_hash_defweak);
2671       h->root.u.def.section = h->weakdef->root.u.def.section;
2672       h->root.u.def.value = h->weakdef->root.u.def.value;
2673       return true;
2674     }
2675
2676   /* This is a reference to a symbol defined by a dynamic object which
2677      is not a function.  The Alpha, since it uses .got entries for all
2678      symbols even in regular objects, does not need the hackery of a
2679      .dynbss section and COPY dynamic relocations.  */
2680
2681   return true;
2682 }
2683
2684 /* Symbol versioning can create new symbols, and make our old symbols
2685    indirect to the new ones.  Consolidate the got and reloc information
2686    in these situations.  */
2687
2688 static boolean
2689 elf64_alpha_merge_ind_symbols (hi, dummy)
2690      struct alpha_elf_link_hash_entry *hi;
2691      PTR dummy;
2692 {
2693   struct alpha_elf_link_hash_entry *hs;
2694
2695   if (hi->root.root.type != bfd_link_hash_indirect)
2696     return true;
2697   hs = hi;
2698   do {
2699     hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2700   } while (hs->root.root.type == bfd_link_hash_indirect);
2701
2702   /* Merge the flags.  Whee.  */
2703
2704   hs->flags |= hi->flags;
2705
2706   /* Merge the .got entries.  Cannibalize the old symbol's list in
2707      doing so, since we don't need it anymore.  */
2708
2709   if (hs->got_entries == NULL)
2710     hs->got_entries = hi->got_entries;
2711   else
2712     {
2713       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2714
2715       gsh = hs->got_entries;
2716       for (gi = hi->got_entries; gi ; gi = gin)
2717         {
2718           gin = gi->next;
2719           for (gs = gsh; gs ; gs = gs->next)
2720             if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2721               goto got_found;
2722           gi->next = hs->got_entries;
2723           hs->got_entries = gi;
2724         got_found:;
2725         }
2726     }
2727   hi->got_entries = NULL;
2728
2729   /* And similar for the reloc entries.  */
2730
2731   if (hs->reloc_entries == NULL)
2732     hs->reloc_entries = hi->reloc_entries;
2733   else
2734     {
2735       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2736
2737       rsh = hs->reloc_entries;
2738       for (ri = hi->reloc_entries; ri ; ri = rin)
2739         {
2740           rin = ri->next;
2741           for (rs = rsh; rs ; rs = rs->next)
2742             if (ri->rtype == rs->rtype)
2743               {
2744                 rs->count += ri->count;
2745                 goto found_reloc;
2746               }
2747           ri->next = hs->reloc_entries;
2748           hs->reloc_entries = ri;
2749         found_reloc:;
2750         }
2751     }
2752   hi->reloc_entries = NULL;
2753
2754   return true;
2755 }
2756
2757 /* Is it possible to merge two object file's .got tables?  */
2758
2759 static boolean
2760 elf64_alpha_can_merge_gots (a, b)
2761      bfd *a, *b;
2762 {
2763   int total = alpha_elf_tdata (a)->total_got_entries;
2764   bfd *bsub;
2765
2766   /* Trivial quick fallout test.  */
2767   if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2768     return true;
2769
2770   /* By their nature, local .got entries cannot be merged.  */
2771   if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2772     return false;
2773
2774   /* Failing the common trivial comparison, we must effectively
2775      perform the merge.  Not actually performing the merge means that
2776      we don't have to store undo information in case we fail.  */
2777   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2778     {
2779       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2780       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2781       int i, n;
2782
2783       n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2784       for (i = 0; i < n; ++i)
2785         {
2786           struct alpha_elf_got_entry *ae, *be;
2787           struct alpha_elf_link_hash_entry *h;
2788
2789           h = hashes[i];
2790           while (h->root.root.type == bfd_link_hash_indirect
2791                  || h->root.root.type == bfd_link_hash_warning)
2792             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2793
2794           for (be = h->got_entries; be ; be = be->next)
2795             {
2796               if (be->use_count == 0)
2797                 continue;
2798               if (be->gotobj != b)
2799                 continue;
2800
2801               for (ae = h->got_entries; ae ; ae = ae->next)
2802                 if (ae->gotobj == a && ae->addend == be->addend)
2803                   goto global_found;
2804
2805               if (++total > MAX_GOT_ENTRIES)
2806                 return false;
2807             global_found:;
2808             }
2809         }
2810     }
2811
2812   return true;
2813 }
2814
2815 /* Actually merge two .got tables.  */
2816
2817 static void
2818 elf64_alpha_merge_gots (a, b)
2819      bfd *a, *b;
2820 {
2821   int total = alpha_elf_tdata (a)->total_got_entries;
2822   bfd *bsub;
2823
2824   /* Remember local expansion.  */
2825   {
2826     int e = alpha_elf_tdata (b)->n_local_got_entries;
2827     total += e;
2828     alpha_elf_tdata (a)->n_local_got_entries += e;
2829   }
2830
2831   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2832     {
2833       struct alpha_elf_got_entry **local_got_entries;
2834       struct alpha_elf_link_hash_entry **hashes;
2835       Elf_Internal_Shdr *symtab_hdr;
2836       int i, n;
2837
2838       /* Let the local .got entries know they are part of a new subsegment.  */
2839       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2840       if (local_got_entries)
2841         {
2842           n = elf_tdata (bsub)->symtab_hdr.sh_info;
2843           for (i = 0; i < n; ++i)
2844             {
2845               struct alpha_elf_got_entry *ent;
2846               for (ent = local_got_entries[i]; ent; ent = ent->next)
2847                 ent->gotobj = a;
2848             }
2849         }
2850
2851       /* Merge the global .got entries.  */
2852       hashes = alpha_elf_sym_hashes (bsub);
2853       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2854
2855       n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2856       for (i = 0; i < n; ++i)
2857         {
2858           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2859           struct alpha_elf_link_hash_entry *h;
2860
2861           h = hashes[i];
2862           while (h->root.root.type == bfd_link_hash_indirect
2863                  || h->root.root.type == bfd_link_hash_warning)
2864             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2865
2866           start = &h->got_entries;
2867           for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2868             {
2869               if (be->use_count == 0)
2870                 {
2871                   *pbe = be->next;
2872                   continue;
2873                 }
2874               if (be->gotobj != b)
2875                 continue;
2876
2877               for (ae = *start; ae ; ae = ae->next)
2878                 if (ae->gotobj == a && ae->addend == be->addend)
2879                   {
2880                     ae->flags |= be->flags;
2881                     ae->use_count += be->use_count;
2882                     *pbe = be->next;
2883                     goto global_found;
2884                   }
2885               be->gotobj = a;
2886               total += 1;
2887
2888             global_found:;
2889             }
2890         }
2891
2892       alpha_elf_tdata (bsub)->gotobj = a;
2893     }
2894   alpha_elf_tdata (a)->total_got_entries = total;
2895
2896   /* Merge the two in_got chains.  */
2897   {
2898     bfd *next;
2899
2900     bsub = a;
2901     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2902       bsub = next;
2903
2904     alpha_elf_tdata (bsub)->in_got_link_next = b;
2905   }
2906 }
2907
2908 /* Calculate the offsets for the got entries.  */
2909
2910 static boolean
2911 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2912      struct alpha_elf_link_hash_entry *h;
2913      PTR arg;
2914 {
2915   struct alpha_elf_got_entry *gotent;
2916
2917   for (gotent = h->got_entries; gotent; gotent = gotent->next)
2918     if (gotent->use_count > 0)
2919       {
2920         bfd_size_type *plge
2921           = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2922
2923         gotent->got_offset = *plge;
2924         *plge += 8;
2925       }
2926
2927   return true;
2928 }
2929
2930 static void
2931 elf64_alpha_calc_got_offsets (info)
2932      struct bfd_link_info *info;
2933 {
2934   bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2935
2936   /* First, zero out the .got sizes, as we may be recalculating the
2937      .got after optimizing it.  */
2938   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2939     alpha_elf_tdata(i)->got->_raw_size = 0;
2940
2941   /* Next, fill in the offsets for all the global entries.  */
2942   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2943                                 elf64_alpha_calc_got_offsets_for_symbol,
2944                                 NULL);
2945
2946   /* Finally, fill in the offsets for the local entries.  */
2947   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2948     {
2949       bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2950       bfd *j;
2951
2952       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2953         {
2954           struct alpha_elf_got_entry **local_got_entries, *gotent;
2955           int k, n;
2956
2957           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2958           if (!local_got_entries)
2959             continue;
2960
2961           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2962             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2963               if (gotent->use_count > 0)
2964                 {
2965                   gotent->got_offset = got_offset;
2966                   got_offset += 8;
2967                 }
2968         }
2969
2970       alpha_elf_tdata(i)->got->_raw_size = got_offset;
2971       alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2972     }
2973 }
2974
2975 /* Constructs the gots.  */
2976
2977 static boolean
2978 elf64_alpha_size_got_sections (output_bfd, info)
2979      bfd *output_bfd;
2980      struct bfd_link_info *info;
2981 {
2982   bfd *i, *got_list, *cur_got_obj;
2983   int something_changed = 0;
2984
2985   got_list = alpha_elf_hash_table (info)->got_list;
2986
2987   /* On the first time through, pretend we have an existing got list
2988      consisting of all of the input files.  */
2989   if (got_list == NULL)
2990     {
2991       for (i = info->input_bfds; i ; i = i->link_next)
2992         {
2993           bfd *this_got = alpha_elf_tdata (i)->gotobj;
2994           if (this_got == NULL)
2995             continue;
2996
2997           /* We are assuming no merging has yet ocurred.  */
2998           BFD_ASSERT (this_got == i);
2999
3000           if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3001             {
3002               /* Yikes! A single object file has too many entries.  */
3003               (*_bfd_error_handler)
3004                 (_("%s: .got subsegment exceeds 64K (size %d)"),
3005                  bfd_get_filename (i),
3006                  alpha_elf_tdata (this_got)->total_got_entries * 8);
3007               return false;
3008             }
3009
3010           if (got_list == NULL)
3011             got_list = this_got;
3012           else
3013             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3014           cur_got_obj = this_got;
3015         }
3016
3017       /* Strange degenerate case of no got references.  */
3018       if (got_list == NULL)
3019         return true;
3020
3021       alpha_elf_hash_table (info)->got_list = got_list;
3022
3023       /* Force got offsets to be recalculated.  */
3024       something_changed = 1;
3025     }
3026
3027   cur_got_obj = got_list;
3028   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3029   while (i != NULL)
3030     {
3031       if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3032         {
3033           elf64_alpha_merge_gots (cur_got_obj, i);
3034           i = alpha_elf_tdata(i)->got_link_next;
3035           alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3036           something_changed = 1;
3037         }
3038       else
3039         {
3040           cur_got_obj = i;
3041           i = alpha_elf_tdata(i)->got_link_next;
3042         }
3043     }
3044
3045   /* Once the gots have been merged, fill in the got offsets for
3046      everything therein.  */
3047   if (1 || something_changed)
3048     elf64_alpha_calc_got_offsets (info);
3049
3050   return true;
3051 }
3052
3053 static boolean
3054 elf64_alpha_always_size_sections (output_bfd, info)
3055      bfd *output_bfd;
3056      struct bfd_link_info *info;
3057 {
3058   bfd *i;
3059
3060   if (info->relocateable)
3061     return true;
3062
3063   /* First, take care of the indirect symbols created by versioning.  */
3064   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3065                                 elf64_alpha_merge_ind_symbols,
3066                                 NULL);
3067
3068   if (!elf64_alpha_size_got_sections (output_bfd, info))
3069     return false;
3070
3071   /* Allocate space for all of the .got subsections.  */
3072   i = alpha_elf_hash_table (info)->got_list;
3073   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3074     {
3075       asection *s = alpha_elf_tdata(i)->got;
3076       if (s->_raw_size > 0)
3077         {
3078           s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3079           if (s->contents == NULL)
3080             return false;
3081         }
3082     }
3083
3084   return true;
3085 }
3086
3087 /* Work out the sizes of the dynamic relocation entries.  */
3088
3089 static boolean
3090 elf64_alpha_calc_dynrel_sizes (h, info)
3091      struct alpha_elf_link_hash_entry *h;
3092      struct bfd_link_info *info;
3093 {
3094   /* If the symbol was defined as a common symbol in a regular object
3095      file, and there was no definition in any dynamic object, then the
3096      linker will have allocated space for the symbol in a common
3097      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3098      set.  This is done for dynamic symbols in
3099      elf_adjust_dynamic_symbol but this is not done for non-dynamic
3100      symbols, somehow.  */
3101   if (((h->root.elf_link_hash_flags
3102        & (ELF_LINK_HASH_DEF_REGULAR
3103           | ELF_LINK_HASH_REF_REGULAR
3104           | ELF_LINK_HASH_DEF_DYNAMIC))
3105        == ELF_LINK_HASH_REF_REGULAR)
3106       && (h->root.root.type == bfd_link_hash_defined
3107           || h->root.root.type == bfd_link_hash_defweak)
3108       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3109     {
3110       h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3111     }
3112
3113   /* If the symbol is dynamic, we'll need all the relocations in their
3114      natural form.  If this is a shared object, and it has been forced
3115      local, we'll need the same number of RELATIVE relocations.  */
3116
3117   if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3118     {
3119       struct alpha_elf_reloc_entry *relent;
3120       bfd *dynobj;
3121       struct alpha_elf_got_entry *gotent;
3122       bfd_size_type count;
3123       asection *srel;
3124
3125       for (relent = h->reloc_entries; relent; relent = relent->next)
3126         if (relent->rtype == R_ALPHA_REFLONG
3127             || relent->rtype == R_ALPHA_REFQUAD)
3128           {
3129             relent->srel->_raw_size +=
3130               sizeof(Elf64_External_Rela) * relent->count;
3131           }
3132
3133       dynobj = elf_hash_table(info)->dynobj;
3134       count = 0;
3135
3136       for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3137         count++;
3138
3139       /* If we are using a .plt entry, subtract one, as the first
3140          reference uses a .rela.plt entry instead.  */
3141       if (h->root.plt.offset != MINUS_ONE)
3142         count--;
3143
3144       if (count > 0)
3145         {
3146           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3147           BFD_ASSERT (srel != NULL);
3148           srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3149         }
3150     }
3151
3152   return true;
3153 }
3154
3155 /* Set the sizes of the dynamic sections.  */
3156
3157 static boolean
3158 elf64_alpha_size_dynamic_sections (output_bfd, info)
3159      bfd *output_bfd;
3160      struct bfd_link_info *info;
3161 {
3162   bfd *dynobj;
3163   asection *s;
3164   boolean reltext;
3165   boolean relplt;
3166
3167   dynobj = elf_hash_table(info)->dynobj;
3168   BFD_ASSERT(dynobj != NULL);
3169
3170   if (elf_hash_table (info)->dynamic_sections_created)
3171     {
3172       /* Set the contents of the .interp section to the interpreter.  */
3173       if (!info->shared)
3174         {
3175           s = bfd_get_section_by_name (dynobj, ".interp");
3176           BFD_ASSERT (s != NULL);
3177           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3178           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3179         }
3180
3181       /* Now that we've seen all of the input files, we can decide which
3182          symbols need dynamic relocation entries and which don't.  We've
3183          collected information in check_relocs that we can now apply to
3184          size the dynamic relocation sections.  */
3185       alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3186                                     elf64_alpha_calc_dynrel_sizes,
3187                                     info);
3188
3189       /* When building shared libraries, each local .got entry needs a
3190          RELATIVE reloc.  */
3191       if (info->shared)
3192         {
3193           bfd *i;
3194           asection *srel;
3195           bfd_size_type count;
3196
3197           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3198           BFD_ASSERT (srel != NULL);
3199
3200           for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3201                i != NULL;
3202                i = alpha_elf_tdata(i)->got_link_next)
3203             count += alpha_elf_tdata(i)->n_local_got_entries;
3204
3205           srel->_raw_size += count * sizeof(Elf64_External_Rela);
3206         }
3207     }
3208   /* else we're not dynamic and by definition we don't need such things.  */
3209
3210   /* The check_relocs and adjust_dynamic_symbol entry points have
3211      determined the sizes of the various dynamic sections.  Allocate
3212      memory for them.  */
3213   reltext = false;
3214   relplt = false;
3215   for (s = dynobj->sections; s != NULL; s = s->next)
3216     {
3217       const char *name;
3218       boolean strip;
3219
3220       if (!(s->flags & SEC_LINKER_CREATED))
3221         continue;
3222
3223       /* It's OK to base decisions on the section name, because none
3224          of the dynobj section names depend upon the input files.  */
3225       name = bfd_get_section_name (dynobj, s);
3226
3227       /* If we don't need this section, strip it from the output file.
3228          This is to handle .rela.bss and .rela.plt.  We must create it
3229          in create_dynamic_sections, because it must be created before
3230          the linker maps input sections to output sections.  The
3231          linker does that before adjust_dynamic_symbol is called, and
3232          it is that function which decides whether anything needs to
3233          go into these sections.  */
3234
3235       strip = false;
3236
3237       if (strncmp (name, ".rela", 5) == 0)
3238         {
3239           strip = (s->_raw_size == 0);
3240
3241           if (!strip)
3242             {
3243               const char *outname;
3244               asection *target;
3245
3246               /* If this relocation section applies to a read only
3247                  section, then we probably need a DT_TEXTREL entry.  */
3248               outname = bfd_get_section_name (output_bfd,
3249                                               s->output_section);
3250               target = bfd_get_section_by_name (output_bfd, outname + 5);
3251               if (target != NULL
3252                   && (target->flags & SEC_READONLY) != 0
3253                   && (target->flags & SEC_ALLOC) != 0)
3254                 reltext = true;
3255
3256               if (strcmp(name, ".rela.plt") == 0)
3257                 relplt = true;
3258
3259               /* We use the reloc_count field as a counter if we need
3260                  to copy relocs into the output file.  */
3261               s->reloc_count = 0;
3262             }
3263         }
3264       else if (strcmp (name, ".plt") != 0)
3265         {
3266           /* It's not one of our dynamic sections, so don't allocate space.  */
3267           continue;
3268         }
3269
3270       if (strip)
3271         _bfd_strip_section_from_output (info, s);
3272       else
3273         {
3274           /* Allocate memory for the section contents.  */
3275           s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3276           if (s->contents == NULL && s->_raw_size != 0)
3277             return false;
3278         }
3279     }
3280
3281   if (elf_hash_table (info)->dynamic_sections_created)
3282     {
3283       /* Add some entries to the .dynamic section.  We fill in the
3284          values later, in elf64_alpha_finish_dynamic_sections, but we
3285          must add the entries now so that we get the correct size for
3286          the .dynamic section.  The DT_DEBUG entry is filled in by the
3287          dynamic linker and used by the debugger.  */
3288       if (!info->shared)
3289         {
3290           if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3291             return false;
3292         }
3293
3294       if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3295         return false;
3296
3297       if (relplt)
3298         {
3299           if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3300               || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3301               || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3302             return false;
3303         }
3304
3305       if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3306           || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3307           || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3308                                             sizeof(Elf64_External_Rela)))
3309         return false;
3310
3311       if (reltext)
3312         {
3313           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3314             return false;
3315           info->flags |= DF_TEXTREL;
3316         }
3317     }
3318
3319   return true;
3320 }
3321
3322 /* Relocate an Alpha ELF section.  */
3323
3324 static boolean
3325 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3326                               contents, relocs, local_syms, local_sections)
3327      bfd *output_bfd;
3328      struct bfd_link_info *info;
3329      bfd *input_bfd;
3330      asection *input_section;
3331      bfd_byte *contents;
3332      Elf_Internal_Rela *relocs;
3333      Elf_Internal_Sym *local_syms;
3334      asection **local_sections;
3335 {
3336   Elf_Internal_Shdr *symtab_hdr;
3337   Elf_Internal_Rela *rel;
3338   Elf_Internal_Rela *relend;
3339   asection *sec, *sgot, *srel, *srelgot;
3340   bfd *dynobj, *gotobj;
3341   bfd_vma gp;
3342
3343   srelgot = srel = NULL;
3344   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3345   dynobj = elf_hash_table (info)->dynobj;
3346   if (dynobj)
3347     {
3348       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3349     }
3350
3351   /* Find the gp value for this input bfd.  */
3352   sgot = NULL;
3353   gp = 0;
3354   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3355   if (gotobj)
3356     {
3357       sgot = alpha_elf_tdata (gotobj)->got;
3358       gp = _bfd_get_gp_value (gotobj);
3359       if (gp == 0)
3360         {
3361           gp = (sgot->output_section->vma
3362                 + sgot->output_offset
3363                 + 0x8000);
3364           _bfd_set_gp_value (gotobj, gp);
3365         }
3366     }
3367
3368   rel = relocs;
3369   relend = relocs + input_section->reloc_count;
3370   for (; rel < relend; rel++)
3371     {
3372       int r_type;
3373       reloc_howto_type *howto;
3374       unsigned long r_symndx;
3375       struct alpha_elf_link_hash_entry *h;
3376       Elf_Internal_Sym *sym;
3377       bfd_vma relocation;
3378       bfd_vma addend;
3379       bfd_reloc_status_type r;
3380
3381       r_type = ELF64_R_TYPE(rel->r_info);
3382       if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3383         {
3384           bfd_set_error (bfd_error_bad_value);
3385           return false;
3386         }
3387       howto = elf64_alpha_howto_table + r_type;
3388
3389       r_symndx = ELF64_R_SYM(rel->r_info);
3390
3391       if (info->relocateable)
3392         {
3393           /* This is a relocateable link.  We don't have to change
3394              anything, unless the reloc is against a section symbol,
3395              in which case we have to adjust according to where the
3396              section symbol winds up in the output section.  */
3397
3398           /* The symbol associated with GPDISP and LITUSE is
3399              immaterial.  Only the addend is significant.  */
3400           if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3401             continue;
3402
3403           if (r_symndx < symtab_hdr->sh_info)
3404             {
3405               sym = local_syms + r_symndx;
3406               if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3407                 {
3408                   sec = local_sections[r_symndx];
3409                   rel->r_addend += sec->output_offset + sym->st_value;
3410                 }
3411             }
3412
3413           continue;
3414         }
3415
3416       /* This is a final link.  */
3417
3418       h = NULL;
3419       sym = NULL;
3420       sec = NULL;
3421
3422       if (r_symndx < symtab_hdr->sh_info)
3423         {
3424           sym = local_syms + r_symndx;
3425           sec = local_sections[r_symndx];
3426           relocation = (sec->output_section->vma
3427                         + sec->output_offset
3428                         + sym->st_value);
3429         }
3430       else
3431         {
3432           h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3433
3434           while (h->root.root.type == bfd_link_hash_indirect
3435                  || h->root.root.type == bfd_link_hash_warning)
3436             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3437
3438           if (h->root.root.type == bfd_link_hash_defined
3439               || h->root.root.type == bfd_link_hash_defweak)
3440             {
3441               sec = h->root.root.u.def.section;
3442
3443 #if rth_notdef
3444               if ((r_type == R_ALPHA_LITERAL
3445                    && elf_hash_table(info)->dynamic_sections_created
3446                    && (!info->shared
3447                        || !info->symbolic
3448                        || !(h->root.elf_link_hash_flags
3449                             & ELF_LINK_HASH_DEF_REGULAR)))
3450                   || (info->shared
3451                       && (!info->symbolic
3452                           || !(h->root.elf_link_hash_flags
3453                                & ELF_LINK_HASH_DEF_REGULAR))
3454                       && (input_section->flags & SEC_ALLOC)
3455                       && (r_type == R_ALPHA_REFLONG
3456                           || r_type == R_ALPHA_REFQUAD
3457                           || r_type == R_ALPHA_LITERAL)))
3458                 {
3459                   /* In these cases, we don't need the relocation value.
3460                      We check specially because in some obscure cases
3461                      sec->output_section will be NULL.  */
3462                   relocation = 0;
3463                 }
3464 #else
3465               /* FIXME: Are not these obscure cases simply bugs?  Let's
3466                  get something working and come back to this.  */
3467               if (sec->output_section == NULL)
3468                 relocation = 0;
3469 #endif /* rth_notdef */
3470               else
3471                 {
3472                   relocation = (h->root.root.u.def.value
3473                                 + sec->output_section->vma
3474                                 + sec->output_offset);
3475                 }
3476             }
3477           else if (h->root.root.type == bfd_link_hash_undefweak)
3478             relocation = 0;
3479           else if (info->shared && !info->symbolic
3480                    && !info->no_undefined
3481                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3482             relocation = 0;
3483           else
3484             {
3485               if (!((*info->callbacks->undefined_symbol)
3486                     (info, h->root.root.root.string, input_bfd,
3487                      input_section, rel->r_offset,
3488                      (!info->shared || info->no_undefined
3489                       || ELF_ST_VISIBILITY (h->root.other)))))
3490                 return false;
3491               relocation = 0;
3492             }
3493         }
3494       addend = rel->r_addend;
3495
3496       switch (r_type)
3497         {
3498         case R_ALPHA_GPDISP:
3499           {
3500             bfd_byte *p_ldah, *p_lda;
3501
3502             BFD_ASSERT(gp != 0);
3503
3504             relocation = (input_section->output_section->vma
3505                           + input_section->output_offset
3506                           + rel->r_offset);
3507
3508             p_ldah = contents + rel->r_offset - input_section->vma;
3509             p_lda = p_ldah + rel->r_addend;
3510
3511             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3512                                              p_ldah, p_lda);
3513           }
3514           break;
3515
3516         case R_ALPHA_OP_PUSH:
3517         case R_ALPHA_OP_STORE:
3518         case R_ALPHA_OP_PSUB:
3519         case R_ALPHA_OP_PRSHIFT:
3520           /* We hate these silly beasts.  */
3521           abort();
3522
3523         case R_ALPHA_LITERAL:
3524           {
3525             struct alpha_elf_got_entry *gotent;
3526             boolean dynamic_symbol;
3527
3528             BFD_ASSERT(sgot != NULL);
3529             BFD_ASSERT(gp != 0);
3530
3531             if (h != NULL)
3532               {
3533                 gotent = h->got_entries;
3534                 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3535               }
3536             else
3537               {
3538                 gotent = (alpha_elf_tdata(input_bfd)->
3539                           local_got_entries[r_symndx]);
3540                 dynamic_symbol = false;
3541               }
3542
3543             BFD_ASSERT(gotent != NULL);
3544
3545             while (gotent->gotobj != gotobj || gotent->addend != addend)
3546               gotent = gotent->next;
3547
3548             BFD_ASSERT(gotent->use_count >= 1);
3549
3550             /* Initialize the .got entry's value.  */
3551             if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3552               {
3553                 bfd_put_64 (output_bfd, relocation+addend,
3554                             sgot->contents + gotent->got_offset);
3555
3556                 /* If the symbol has been forced local, output a
3557                    RELATIVE reloc, otherwise it will be handled in
3558                    finish_dynamic_symbol.  */
3559                 if (info->shared && !dynamic_symbol)
3560                   {
3561                     Elf_Internal_Rela outrel;
3562
3563                     BFD_ASSERT(srelgot != NULL);
3564
3565                     outrel.r_offset = (sgot->output_section->vma
3566                                        + sgot->output_offset
3567                                        + gotent->got_offset);
3568                     outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3569                     outrel.r_addend = 0;
3570
3571                     bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3572                                                ((Elf64_External_Rela *)
3573                                                 srelgot->contents)
3574                                                + srelgot->reloc_count++);
3575                     BFD_ASSERT (sizeof(Elf64_External_Rela)
3576                                 * srelgot->reloc_count
3577                                 <= srelgot->_cooked_size);
3578                   }
3579
3580                 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3581               }
3582
3583             /* Figure the gprel relocation.  */
3584             addend = 0;
3585             relocation = (sgot->output_section->vma
3586                           + sgot->output_offset
3587                           + gotent->got_offset);
3588             relocation -= gp;
3589           }
3590           /* overflow handled by _bfd_final_link_relocate */
3591           goto default_reloc;
3592
3593         case R_ALPHA_GPREL32:
3594         case R_ALPHA_GPRELLOW:
3595           BFD_ASSERT(gp != 0);
3596           relocation -= gp;
3597           goto default_reloc;
3598
3599         case R_ALPHA_GPRELHIGH:
3600           BFD_ASSERT(gp != 0);
3601           relocation -= gp;
3602           relocation += addend;
3603           addend = 0;
3604           relocation = (((bfd_signed_vma) relocation >> 16)
3605                         + ((relocation >> 15) & 1));
3606           goto default_reloc;
3607
3608         case R_ALPHA_BRADDR:
3609         case R_ALPHA_HINT:
3610           /* The regular PC-relative stuff measures from the start of
3611              the instruction rather than the end.  */
3612           addend -= 4;
3613           goto default_reloc;
3614
3615         case R_ALPHA_REFLONG:
3616         case R_ALPHA_REFQUAD:
3617           {
3618             Elf_Internal_Rela outrel;
3619             boolean skip;
3620
3621             /* Careful here to remember RELATIVE relocations for global
3622                variables for symbolic shared objects.  */
3623
3624             if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3625               {
3626                 BFD_ASSERT(h->root.dynindx != -1);
3627                 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3628                 outrel.r_addend = addend;
3629                 addend = 0, relocation = 0;
3630               }
3631             else if (info->shared && (input_section->flags & SEC_ALLOC))
3632               {
3633                 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3634                 outrel.r_addend = 0;
3635               }
3636             else
3637               goto default_reloc;
3638
3639             if (!srel)
3640               {
3641                 const char *name;
3642
3643                 name = (bfd_elf_string_from_elf_section
3644                         (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3645                          elf_section_data(input_section)->rel_hdr.sh_name));
3646                 BFD_ASSERT(name != NULL);
3647
3648                 srel = bfd_get_section_by_name (dynobj, name);
3649                 BFD_ASSERT(srel != NULL);
3650               }
3651
3652             skip = false;
3653
3654             if (elf_section_data (input_section)->stab_info == NULL)
3655               outrel.r_offset = rel->r_offset;
3656             else
3657               {
3658                 bfd_vma off;
3659
3660                 off = (_bfd_stab_section_offset
3661                        (output_bfd, &elf_hash_table (info)->stab_info,
3662                         input_section,
3663                         &elf_section_data (input_section)->stab_info,
3664                         rel->r_offset));
3665                 if (off == (bfd_vma) -1)
3666                   skip = true;
3667                 outrel.r_offset = off;
3668               }
3669
3670             if (! skip)
3671               outrel.r_offset += (input_section->output_section->vma
3672                                   + input_section->output_offset);
3673             else
3674               memset (&outrel, 0, sizeof outrel);
3675
3676             bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3677                                        ((Elf64_External_Rela *)
3678                                         srel->contents)
3679                                        + srel->reloc_count++);
3680             BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3681                         <= srel->_cooked_size);
3682           }
3683           goto default_reloc;
3684
3685         default:
3686         default_reloc:
3687           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3688                                         contents, rel->r_offset, relocation,
3689                                         addend);
3690           break;
3691         }
3692
3693       switch (r)
3694         {
3695         case bfd_reloc_ok:
3696           break;
3697
3698         case bfd_reloc_overflow:
3699           {
3700             const char *name;
3701
3702             if (h != NULL)
3703               name = h->root.root.root.string;
3704             else
3705               {
3706                 name = (bfd_elf_string_from_elf_section
3707                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
3708                 if (name == NULL)
3709                   return false;
3710                 if (*name == '\0')
3711                   name = bfd_section_name (input_bfd, sec);
3712               }
3713             if (! ((*info->callbacks->reloc_overflow)
3714                    (info, name, howto->name, (bfd_vma) 0,
3715                     input_bfd, input_section, rel->r_offset)))
3716               return false;
3717           }
3718           break;
3719
3720         default:
3721         case bfd_reloc_outofrange:
3722           abort ();
3723         }
3724     }
3725
3726   return true;
3727 }
3728
3729 /* Finish up dynamic symbol handling.  We set the contents of various
3730    dynamic sections here.  */
3731
3732 static boolean
3733 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3734      bfd *output_bfd;
3735      struct bfd_link_info *info;
3736      struct elf_link_hash_entry *h;
3737      Elf_Internal_Sym *sym;
3738 {
3739   bfd *dynobj = elf_hash_table(info)->dynobj;
3740
3741   if (h->plt.offset != MINUS_ONE)
3742     {
3743       /* Fill in the .plt entry for this symbol.  */
3744       asection *splt, *sgot, *srel;
3745       Elf_Internal_Rela outrel;
3746       bfd_vma got_addr, plt_addr;
3747       bfd_vma plt_index;
3748       struct alpha_elf_got_entry *gotent;
3749
3750       BFD_ASSERT (h->dynindx != -1);
3751
3752       /* The first .got entry will be updated by the .plt with the
3753          address of the target function.  */
3754       gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3755       BFD_ASSERT (gotent && gotent->addend == 0);
3756
3757       splt = bfd_get_section_by_name (dynobj, ".plt");
3758       BFD_ASSERT (splt != NULL);
3759       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3760       BFD_ASSERT (srel != NULL);
3761       sgot = alpha_elf_tdata (gotent->gotobj)->got;
3762       BFD_ASSERT (sgot != NULL);
3763
3764       got_addr = (sgot->output_section->vma
3765                   + sgot->output_offset
3766                   + gotent->got_offset);
3767       plt_addr = (splt->output_section->vma
3768                   + splt->output_offset
3769                   + h->plt.offset);
3770
3771       plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3772
3773       /* Fill in the entry in the procedure linkage table.  */
3774       {
3775         unsigned insn1, insn2, insn3;
3776
3777         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3778         insn2 = PLT_ENTRY_WORD2;
3779         insn3 = PLT_ENTRY_WORD3;
3780
3781         bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3782         bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3783         bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3784       }
3785
3786       /* Fill in the entry in the .rela.plt section.  */
3787       outrel.r_offset = got_addr;
3788       outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3789       outrel.r_addend = 0;
3790
3791       bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3792                                  ((Elf64_External_Rela *)srel->contents
3793                                   + plt_index));
3794
3795       if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3796         {
3797           /* Mark the symbol as undefined, rather than as defined in the
3798              .plt section.  Leave the value alone.  */
3799           sym->st_shndx = SHN_UNDEF;
3800         }
3801
3802       /* Fill in the entries in the .got.  */
3803       bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3804
3805       /* Subsequent .got entries will continue to bounce through the .plt.  */
3806       if (gotent->next)
3807         {
3808           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3809           BFD_ASSERT (! info->shared || srel != NULL);
3810
3811           gotent = gotent->next;
3812           do
3813             {
3814               sgot = alpha_elf_tdata(gotent->gotobj)->got;
3815               BFD_ASSERT(sgot != NULL);
3816               BFD_ASSERT(gotent->addend == 0);
3817
3818               bfd_put_64 (output_bfd, plt_addr,
3819                           sgot->contents + gotent->got_offset);
3820
3821               if (info->shared)
3822                 {
3823                   outrel.r_offset = (sgot->output_section->vma
3824                                      + sgot->output_offset
3825                                      + gotent->got_offset);
3826                   outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3827                   outrel.r_addend = 0;
3828
3829                   bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3830                                              ((Elf64_External_Rela *)
3831                                               srel->contents)
3832                                              + srel->reloc_count++);
3833                   BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3834                               <= srel->_cooked_size);
3835                 }
3836
3837               gotent = gotent->next;
3838             }
3839           while (gotent != NULL);
3840         }
3841     }
3842   else if (alpha_elf_dynamic_symbol_p (h, info))
3843     {
3844       /* Fill in the dynamic relocations for this symbol's .got entries.  */
3845       asection *srel;
3846       Elf_Internal_Rela outrel;
3847       struct alpha_elf_got_entry *gotent;
3848
3849       srel = bfd_get_section_by_name (dynobj, ".rela.got");
3850       BFD_ASSERT (srel != NULL);
3851
3852       outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3853       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3854            gotent != NULL;
3855            gotent = gotent->next)
3856         {
3857           asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3858           outrel.r_offset = (sgot->output_section->vma
3859                              + sgot->output_offset
3860                              + gotent->got_offset);
3861           outrel.r_addend = gotent->addend;
3862
3863           bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3864                                      ((Elf64_External_Rela *)srel->contents
3865                                       + srel->reloc_count++));
3866           BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3867                       <= srel->_cooked_size);
3868         }
3869     }
3870
3871   /* Mark some specially defined symbols as absolute.  */
3872   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3873       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3874       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3875     sym->st_shndx = SHN_ABS;
3876
3877   return true;
3878 }
3879
3880 /* Finish up the dynamic sections.  */
3881
3882 static boolean
3883 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3884      bfd *output_bfd;
3885      struct bfd_link_info *info;
3886 {
3887   bfd *dynobj;
3888   asection *sdyn;
3889
3890   dynobj = elf_hash_table (info)->dynobj;
3891   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3892
3893   if (elf_hash_table (info)->dynamic_sections_created)
3894     {
3895       asection *splt;
3896       Elf64_External_Dyn *dyncon, *dynconend;
3897
3898       splt = bfd_get_section_by_name (dynobj, ".plt");
3899       BFD_ASSERT (splt != NULL && sdyn != NULL);
3900
3901       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3902       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3903       for (; dyncon < dynconend; dyncon++)
3904         {
3905           Elf_Internal_Dyn dyn;
3906           const char *name;
3907           asection *s;
3908
3909           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3910
3911           switch (dyn.d_tag)
3912             {
3913             case DT_PLTGOT:
3914               name = ".plt";
3915               goto get_vma;
3916             case DT_PLTRELSZ:
3917               name = ".rela.plt";
3918               goto get_size;
3919             case DT_JMPREL:
3920               name = ".rela.plt";
3921               goto get_vma;
3922
3923             case DT_RELASZ:
3924               /* My interpretation of the TIS v1.1 ELF document indicates
3925                  that RELASZ should not include JMPREL.  This is not what
3926                  the rest of the BFD does.  It is, however, what the
3927                  glibc ld.so wants.  Do this fixup here until we found
3928                  out who is right.  */
3929               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3930               if (s)
3931                 {
3932                   dyn.d_un.d_val -=
3933                     (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3934                 }
3935               break;
3936
3937             get_vma:
3938               s = bfd_get_section_by_name (output_bfd, name);
3939               dyn.d_un.d_ptr = (s ? s->vma : 0);
3940               break;
3941
3942             get_size:
3943               s = bfd_get_section_by_name (output_bfd, name);
3944               dyn.d_un.d_val =
3945                 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3946               break;
3947             }
3948
3949           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3950         }
3951
3952       /* Initialize the PLT0 entry */
3953       if (splt->_raw_size > 0)
3954         {
3955           bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3956           bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3957           bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3958           bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3959
3960           /* The next two words will be filled in by ld.so */
3961           bfd_put_64 (output_bfd, 0, splt->contents + 16);
3962           bfd_put_64 (output_bfd, 0, splt->contents + 24);
3963
3964           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3965             PLT_HEADER_SIZE;
3966         }
3967     }
3968
3969   return true;
3970 }
3971
3972 /* We need to use a special link routine to handle the .reginfo and
3973    the .mdebug sections.  We need to merge all instances of these
3974    sections together, not write them all out sequentially.  */
3975
3976 static boolean
3977 elf64_alpha_final_link (abfd, info)
3978      bfd *abfd;
3979      struct bfd_link_info *info;
3980 {
3981   asection *o;
3982   struct bfd_link_order *p;
3983   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3984   struct ecoff_debug_info debug;
3985   const struct ecoff_debug_swap *swap
3986     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3987   HDRR *symhdr = &debug.symbolic_header;
3988   PTR mdebug_handle = NULL;
3989
3990 #if 0
3991               if (++ngots == 2)
3992                 {
3993                   (*info->callbacks->warning)
3994                     (info, _("using multiple gp values"), (char *) NULL,
3995                      output_bfd, (asection *) NULL, (bfd_vma) 0);
3996                 }
3997 #endif
3998
3999   /* Go through the sections and collect the .reginfo and .mdebug
4000      information.  */
4001   reginfo_sec = NULL;
4002   mdebug_sec = NULL;
4003   gptab_data_sec = NULL;
4004   gptab_bss_sec = NULL;
4005   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4006     {
4007 #ifdef ERIC_neverdef
4008       if (strcmp (o->name, ".reginfo") == 0)
4009         {
4010           memset (&reginfo, 0, sizeof reginfo);
4011
4012           /* We have found the .reginfo section in the output file.
4013              Look through all the link_orders comprising it and merge
4014              the information together.  */
4015           for (p = o->link_order_head;
4016                p != (struct bfd_link_order *) NULL;
4017                p = p->next)
4018             {
4019               asection *input_section;
4020               bfd *input_bfd;
4021               Elf64_External_RegInfo ext;
4022               Elf64_RegInfo sub;
4023
4024               if (p->type != bfd_indirect_link_order)
4025                 {
4026                   if (p->type == bfd_fill_link_order)
4027                     continue;
4028                   abort ();
4029                 }
4030
4031               input_section = p->u.indirect.section;
4032               input_bfd = input_section->owner;
4033
4034               /* The linker emulation code has probably clobbered the
4035                  size to be zero bytes.  */
4036               if (input_section->_raw_size == 0)
4037                 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4038
4039               if (! bfd_get_section_contents (input_bfd, input_section,
4040                                               (PTR) &ext,
4041                                               (file_ptr) 0,
4042                                               sizeof ext))
4043                 return false;
4044
4045               bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4046
4047               reginfo.ri_gprmask |= sub.ri_gprmask;
4048               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4049               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4050               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4051               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4052
4053               /* ri_gp_value is set by the function
4054                  alpha_elf_section_processing when the section is
4055                  finally written out.  */
4056
4057               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4058                  elf_link_input_bfd ignores this section.  */
4059               input_section->flags &=~ SEC_HAS_CONTENTS;
4060             }
4061
4062           /* Force the section size to the value we want.  */
4063           o->_raw_size = sizeof (Elf64_External_RegInfo);
4064
4065           /* Skip this section later on (I don't think this currently
4066              matters, but someday it might).  */
4067           o->link_order_head = (struct bfd_link_order *) NULL;
4068
4069           reginfo_sec = o;
4070         }
4071 #endif
4072
4073       if (strcmp (o->name, ".mdebug") == 0)
4074         {
4075           struct extsym_info einfo;
4076
4077           /* We have found the .mdebug section in the output file.
4078              Look through all the link_orders comprising it and merge
4079              the information together.  */
4080           symhdr->magic = swap->sym_magic;
4081           /* FIXME: What should the version stamp be?  */
4082           symhdr->vstamp = 0;
4083           symhdr->ilineMax = 0;
4084           symhdr->cbLine = 0;
4085           symhdr->idnMax = 0;
4086           symhdr->ipdMax = 0;
4087           symhdr->isymMax = 0;
4088           symhdr->ioptMax = 0;
4089           symhdr->iauxMax = 0;
4090           symhdr->issMax = 0;
4091           symhdr->issExtMax = 0;
4092           symhdr->ifdMax = 0;
4093           symhdr->crfd = 0;
4094           symhdr->iextMax = 0;
4095
4096           /* We accumulate the debugging information itself in the
4097              debug_info structure.  */
4098           debug.line = NULL;
4099           debug.external_dnr = NULL;
4100           debug.external_pdr = NULL;
4101           debug.external_sym = NULL;
4102           debug.external_opt = NULL;
4103           debug.external_aux = NULL;
4104           debug.ss = NULL;
4105           debug.ssext = debug.ssext_end = NULL;
4106           debug.external_fdr = NULL;
4107           debug.external_rfd = NULL;
4108           debug.external_ext = debug.external_ext_end = NULL;
4109
4110           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4111           if (mdebug_handle == (PTR) NULL)
4112             return false;
4113
4114           if (1)
4115             {
4116               asection *s;
4117               EXTR esym;
4118               bfd_vma last;
4119               unsigned int i;
4120               static const char * const name[] =
4121                 {
4122                   ".text", ".init", ".fini", ".data",
4123                   ".rodata", ".sdata", ".sbss", ".bss"
4124                 };
4125               static const int sc[] = { scText, scInit, scFini, scData,
4126                                           scRData, scSData, scSBss, scBss };
4127
4128               esym.jmptbl = 0;
4129               esym.cobol_main = 0;
4130               esym.weakext = 0;
4131               esym.reserved = 0;
4132               esym.ifd = ifdNil;
4133               esym.asym.iss = issNil;
4134               esym.asym.st = stLocal;
4135               esym.asym.reserved = 0;
4136               esym.asym.index = indexNil;
4137               for (i = 0; i < 8; i++)
4138                 {
4139                   esym.asym.sc = sc[i];
4140                   s = bfd_get_section_by_name (abfd, name[i]);
4141                   if (s != NULL)
4142                     {
4143                       esym.asym.value = s->vma;
4144                       last = s->vma + s->_raw_size;
4145                     }
4146                   else
4147                     esym.asym.value = last;
4148
4149                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4150                                                       name[i], &esym))
4151                     return false;
4152                 }
4153             }
4154
4155           for (p = o->link_order_head;
4156                p != (struct bfd_link_order *) NULL;
4157                p = p->next)
4158             {
4159               asection *input_section;
4160               bfd *input_bfd;
4161               const struct ecoff_debug_swap *input_swap;
4162               struct ecoff_debug_info input_debug;
4163               char *eraw_src;
4164               char *eraw_end;
4165
4166               if (p->type != bfd_indirect_link_order)
4167                 {
4168                   if (p->type == bfd_fill_link_order)
4169                     continue;
4170                   abort ();
4171                 }
4172
4173               input_section = p->u.indirect.section;
4174               input_bfd = input_section->owner;
4175
4176               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4177                   || (get_elf_backend_data (input_bfd)
4178                       ->elf_backend_ecoff_debug_swap) == NULL)
4179                 {
4180                   /* I don't know what a non ALPHA ELF bfd would be
4181                      doing with a .mdebug section, but I don't really
4182                      want to deal with it.  */
4183                   continue;
4184                 }
4185
4186               input_swap = (get_elf_backend_data (input_bfd)
4187                             ->elf_backend_ecoff_debug_swap);
4188
4189               BFD_ASSERT (p->size == input_section->_raw_size);
4190
4191               /* The ECOFF linking code expects that we have already
4192                  read in the debugging information and set up an
4193                  ecoff_debug_info structure, so we do that now.  */
4194               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4195                                                 &input_debug))
4196                 return false;
4197
4198               if (! (bfd_ecoff_debug_accumulate
4199                      (mdebug_handle, abfd, &debug, swap, input_bfd,
4200                       &input_debug, input_swap, info)))
4201                 return false;
4202
4203               /* Loop through the external symbols.  For each one with
4204                  interesting information, try to find the symbol in
4205                  the linker global hash table and save the information
4206                  for the output external symbols.  */
4207               eraw_src = input_debug.external_ext;
4208               eraw_end = (eraw_src
4209                           + (input_debug.symbolic_header.iextMax
4210                              * input_swap->external_ext_size));
4211               for (;
4212                    eraw_src < eraw_end;
4213                    eraw_src += input_swap->external_ext_size)
4214                 {
4215                   EXTR ext;
4216                   const char *name;
4217                   struct alpha_elf_link_hash_entry *h;
4218
4219                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4220                   if (ext.asym.sc == scNil
4221                       || ext.asym.sc == scUndefined
4222                       || ext.asym.sc == scSUndefined)
4223                     continue;
4224
4225                   name = input_debug.ssext + ext.asym.iss;
4226                   h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4227                                                   name, false, false, true);
4228                   if (h == NULL || h->esym.ifd != -2)
4229                     continue;
4230
4231                   if (ext.ifd != -1)
4232                     {
4233                       BFD_ASSERT (ext.ifd
4234                                   < input_debug.symbolic_header.ifdMax);
4235                       ext.ifd = input_debug.ifdmap[ext.ifd];
4236                     }
4237
4238                   h->esym = ext;
4239                 }
4240
4241               /* Free up the information we just read.  */
4242               free (input_debug.line);
4243               free (input_debug.external_dnr);
4244               free (input_debug.external_pdr);
4245               free (input_debug.external_sym);
4246               free (input_debug.external_opt);
4247               free (input_debug.external_aux);
4248               free (input_debug.ss);
4249               free (input_debug.ssext);
4250               free (input_debug.external_fdr);
4251               free (input_debug.external_rfd);
4252               free (input_debug.external_ext);
4253
4254               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4255                  elf_link_input_bfd ignores this section.  */
4256               input_section->flags &=~ SEC_HAS_CONTENTS;
4257             }
4258
4259 #ifdef ERIC_neverdef
4260           if (info->shared)
4261             {
4262               /* Create .rtproc section.  */
4263               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4264               if (rtproc_sec == NULL)
4265                 {
4266                   flagword flags = (SEC_HAS_CONTENTS
4267                                     | SEC_IN_MEMORY
4268                                     | SEC_LINKER_CREATED
4269                                     | SEC_READONLY);
4270
4271                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
4272                   if (rtproc_sec == NULL
4273                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4274                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4275                     return false;
4276                 }
4277
4278               if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4279                                                      info, rtproc_sec, &debug))
4280                 return false;
4281             }
4282 #endif
4283
4284
4285           /* Build the external symbol information.  */
4286           einfo.abfd = abfd;
4287           einfo.info = info;
4288           einfo.debug = &debug;
4289           einfo.swap = swap;
4290           einfo.failed = false;
4291           elf_link_hash_traverse (elf_hash_table (info),
4292                                   elf64_alpha_output_extsym,
4293                                   (PTR) &einfo);
4294           if (einfo.failed)
4295             return false;
4296
4297           /* Set the size of the .mdebug section.  */
4298           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4299
4300           /* Skip this section later on (I don't think this currently
4301              matters, but someday it might).  */
4302           o->link_order_head = (struct bfd_link_order *) NULL;
4303
4304           mdebug_sec = o;
4305         }
4306
4307 #ifdef ERIC_neverdef
4308       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4309         {
4310           const char *subname;
4311           unsigned int c;
4312           Elf64_gptab *tab;
4313           Elf64_External_gptab *ext_tab;
4314           unsigned int i;
4315
4316           /* The .gptab.sdata and .gptab.sbss sections hold
4317              information describing how the small data area would
4318              change depending upon the -G switch.  These sections
4319              not used in executables files.  */
4320           if (! info->relocateable)
4321             {
4322               asection **secpp;
4323
4324               for (p = o->link_order_head;
4325                    p != (struct bfd_link_order *) NULL;
4326                    p = p->next)
4327                 {
4328                   asection *input_section;
4329
4330                   if (p->type != bfd_indirect_link_order)
4331                     {
4332                       if (p->type == bfd_fill_link_order)
4333                         continue;
4334                       abort ();
4335                     }
4336
4337                   input_section = p->u.indirect.section;
4338
4339                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
4340                      elf_link_input_bfd ignores this section.  */
4341                   input_section->flags &=~ SEC_HAS_CONTENTS;
4342                 }
4343
4344               /* Skip this section later on (I don't think this
4345                  currently matters, but someday it might).  */
4346               o->link_order_head = (struct bfd_link_order *) NULL;
4347
4348               /* Really remove the section.  */
4349               for (secpp = &abfd->sections;
4350                    *secpp != o;
4351                    secpp = &(*secpp)->next)
4352                 ;
4353               *secpp = (*secpp)->next;
4354               --abfd->section_count;
4355
4356               continue;
4357             }
4358
4359           /* There is one gptab for initialized data, and one for
4360              uninitialized data.  */
4361           if (strcmp (o->name, ".gptab.sdata") == 0)
4362             gptab_data_sec = o;
4363           else if (strcmp (o->name, ".gptab.sbss") == 0)
4364             gptab_bss_sec = o;
4365           else
4366             {
4367               (*_bfd_error_handler)
4368                 (_("%s: illegal section name `%s'"),
4369                  bfd_get_filename (abfd), o->name);
4370               bfd_set_error (bfd_error_nonrepresentable_section);
4371               return false;
4372             }
4373
4374           /* The linker script always combines .gptab.data and
4375              .gptab.sdata into .gptab.sdata, and likewise for
4376              .gptab.bss and .gptab.sbss.  It is possible that there is
4377              no .sdata or .sbss section in the output file, in which
4378              case we must change the name of the output section.  */
4379           subname = o->name + sizeof ".gptab" - 1;
4380           if (bfd_get_section_by_name (abfd, subname) == NULL)
4381             {
4382               if (o == gptab_data_sec)
4383                 o->name = ".gptab.data";
4384               else
4385                 o->name = ".gptab.bss";
4386               subname = o->name + sizeof ".gptab" - 1;
4387               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4388             }
4389
4390           /* Set up the first entry.  */
4391           c = 1;
4392           tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4393           if (tab == NULL)
4394             return false;
4395           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4396           tab[0].gt_header.gt_unused = 0;
4397
4398           /* Combine the input sections.  */
4399           for (p = o->link_order_head;
4400                p != (struct bfd_link_order *) NULL;
4401                p = p->next)
4402             {
4403               asection *input_section;
4404               bfd *input_bfd;
4405               bfd_size_type size;
4406               unsigned long last;
4407               bfd_size_type gpentry;
4408
4409               if (p->type != bfd_indirect_link_order)
4410                 {
4411                   if (p->type == bfd_fill_link_order)
4412                     continue;
4413                   abort ();
4414                 }
4415
4416               input_section = p->u.indirect.section;
4417               input_bfd = input_section->owner;
4418
4419               /* Combine the gptab entries for this input section one
4420                  by one.  We know that the input gptab entries are
4421                  sorted by ascending -G value.  */
4422               size = bfd_section_size (input_bfd, input_section);
4423               last = 0;
4424               for (gpentry = sizeof (Elf64_External_gptab);
4425                    gpentry < size;
4426                    gpentry += sizeof (Elf64_External_gptab))
4427                 {
4428                   Elf64_External_gptab ext_gptab;
4429                   Elf64_gptab int_gptab;
4430                   unsigned long val;
4431                   unsigned long add;
4432                   boolean exact;
4433                   unsigned int look;
4434
4435                   if (! (bfd_get_section_contents
4436                          (input_bfd, input_section, (PTR) &ext_gptab,
4437                           gpentry, sizeof (Elf64_External_gptab))))
4438                     {
4439                       free (tab);
4440                       return false;
4441                     }
4442
4443                   bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4444                                                 &int_gptab);
4445                   val = int_gptab.gt_entry.gt_g_value;
4446                   add = int_gptab.gt_entry.gt_bytes - last;
4447
4448                   exact = false;
4449                   for (look = 1; look < c; look++)
4450                     {
4451                       if (tab[look].gt_entry.gt_g_value >= val)
4452                         tab[look].gt_entry.gt_bytes += add;
4453
4454                       if (tab[look].gt_entry.gt_g_value == val)
4455                         exact = true;
4456                     }
4457
4458                   if (! exact)
4459                     {
4460                       Elf64_gptab *new_tab;
4461                       unsigned int max;
4462
4463                       /* We need a new table entry.  */
4464                       new_tab = ((Elf64_gptab *)
4465                                  bfd_realloc ((PTR) tab,
4466                                               (c + 1) * sizeof (Elf64_gptab)));
4467                       if (new_tab == NULL)
4468                         {
4469                           free (tab);
4470                           return false;
4471                         }
4472                       tab = new_tab;
4473                       tab[c].gt_entry.gt_g_value = val;
4474                       tab[c].gt_entry.gt_bytes = add;
4475
4476                       /* Merge in the size for the next smallest -G
4477                          value, since that will be implied by this new
4478                          value.  */
4479                       max = 0;
4480                       for (look = 1; look < c; look++)
4481                         {
4482                           if (tab[look].gt_entry.gt_g_value < val
4483                               && (max == 0
4484                                   || (tab[look].gt_entry.gt_g_value
4485                                       > tab[max].gt_entry.gt_g_value)))
4486                             max = look;
4487                         }
4488                       if (max != 0)
4489                         tab[c].gt_entry.gt_bytes +=
4490                           tab[max].gt_entry.gt_bytes;
4491
4492                       ++c;
4493                     }
4494
4495                   last = int_gptab.gt_entry.gt_bytes;
4496                 }
4497
4498               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4499                  elf_link_input_bfd ignores this section.  */
4500               input_section->flags &=~ SEC_HAS_CONTENTS;
4501             }
4502
4503           /* The table must be sorted by -G value.  */
4504           if (c > 2)
4505             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4506
4507           /* Swap out the table.  */
4508           ext_tab = ((Elf64_External_gptab *)
4509                      bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4510           if (ext_tab == NULL)
4511             {
4512               free (tab);
4513               return false;
4514             }
4515
4516           for (i = 0; i < c; i++)
4517             bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4518           free (tab);
4519
4520           o->_raw_size = c * sizeof (Elf64_External_gptab);
4521           o->contents = (bfd_byte *) ext_tab;
4522
4523           /* Skip this section later on (I don't think this currently
4524              matters, but someday it might).  */
4525           o->link_order_head = (struct bfd_link_order *) NULL;
4526         }
4527 #endif
4528
4529     }
4530
4531   /* Invoke the regular ELF backend linker to do all the work.  */
4532   if (! bfd_elf64_bfd_final_link (abfd, info))
4533     return false;
4534
4535   /* Now write out the computed sections.  */
4536
4537   /* The .got subsections...  */
4538   {
4539     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4540     for (i = alpha_elf_hash_table(info)->got_list;
4541          i != NULL;
4542          i = alpha_elf_tdata(i)->got_link_next)
4543       {
4544         asection *sgot;
4545
4546         /* elf_bfd_final_link already did everything in dynobj.  */
4547         if (i == dynobj)
4548           continue;
4549
4550         sgot = alpha_elf_tdata(i)->got;
4551         if (! bfd_set_section_contents (abfd, sgot->output_section,
4552                                         sgot->contents, sgot->output_offset,
4553                                         sgot->_raw_size))
4554           return false;
4555       }
4556   }
4557
4558 #ifdef ERIC_neverdef
4559   if (reginfo_sec != (asection *) NULL)
4560     {
4561       Elf64_External_RegInfo ext;
4562
4563       bfd_alpha_elf64_swap_reginfo_out (abfd, &reginfo, &ext);
4564       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4565                                       (file_ptr) 0, sizeof ext))
4566         return false;
4567     }
4568 #endif
4569
4570   if (mdebug_sec != (asection *) NULL)
4571     {
4572       BFD_ASSERT (abfd->output_has_begun);
4573       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4574                                                swap, info,
4575                                                mdebug_sec->filepos))
4576         return false;
4577
4578       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4579     }
4580
4581   if (gptab_data_sec != (asection *) NULL)
4582     {
4583       if (! bfd_set_section_contents (abfd, gptab_data_sec,
4584                                       gptab_data_sec->contents,
4585                                       (file_ptr) 0,
4586                                       gptab_data_sec->_raw_size))
4587         return false;
4588     }
4589
4590   if (gptab_bss_sec != (asection *) NULL)
4591     {
4592       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4593                                       gptab_bss_sec->contents,
4594                                       (file_ptr) 0,
4595                                       gptab_bss_sec->_raw_size))
4596         return false;
4597     }
4598
4599   return true;
4600 }
4601 \f
4602 /* ECOFF swapping routines.  These are used when dealing with the
4603    .mdebug section, which is in the ECOFF debugging format.  Copied
4604    from elf32-mips.c. */
4605 static const struct ecoff_debug_swap
4606 elf64_alpha_ecoff_debug_swap =
4607 {
4608   /* Symbol table magic number.  */
4609   magicSym2,
4610   /* Alignment of debugging information.  E.g., 4.  */
4611   8,
4612   /* Sizes of external symbolic information.  */
4613   sizeof (struct hdr_ext),
4614   sizeof (struct dnr_ext),
4615   sizeof (struct pdr_ext),
4616   sizeof (struct sym_ext),
4617   sizeof (struct opt_ext),
4618   sizeof (struct fdr_ext),
4619   sizeof (struct rfd_ext),
4620   sizeof (struct ext_ext),
4621   /* Functions to swap in external symbolic data.  */
4622   ecoff_swap_hdr_in,
4623   ecoff_swap_dnr_in,
4624   ecoff_swap_pdr_in,
4625   ecoff_swap_sym_in,
4626   ecoff_swap_opt_in,
4627   ecoff_swap_fdr_in,
4628   ecoff_swap_rfd_in,
4629   ecoff_swap_ext_in,
4630   _bfd_ecoff_swap_tir_in,
4631   _bfd_ecoff_swap_rndx_in,
4632   /* Functions to swap out external symbolic data.  */
4633   ecoff_swap_hdr_out,
4634   ecoff_swap_dnr_out,
4635   ecoff_swap_pdr_out,
4636   ecoff_swap_sym_out,
4637   ecoff_swap_opt_out,
4638   ecoff_swap_fdr_out,
4639   ecoff_swap_rfd_out,
4640   ecoff_swap_ext_out,
4641   _bfd_ecoff_swap_tir_out,
4642   _bfd_ecoff_swap_rndx_out,
4643   /* Function to read in symbolic data.  */
4644   elf64_alpha_read_ecoff_info
4645 };
4646 \f
4647 /* Use a non-standard hash bucket size of 8.  */
4648
4649 const struct elf_size_info alpha_elf_size_info =
4650 {
4651   sizeof (Elf64_External_Ehdr),
4652   sizeof (Elf64_External_Phdr),
4653   sizeof (Elf64_External_Shdr),
4654   sizeof (Elf64_External_Rel),
4655   sizeof (Elf64_External_Rela),
4656   sizeof (Elf64_External_Sym),
4657   sizeof (Elf64_External_Dyn),
4658   sizeof (Elf_External_Note),
4659   8,
4660   1,
4661   64, 8,
4662   ELFCLASS64, EV_CURRENT,
4663   bfd_elf64_write_out_phdrs,
4664   bfd_elf64_write_shdrs_and_ehdr,
4665   bfd_elf64_write_relocs,
4666   bfd_elf64_swap_symbol_out,
4667   bfd_elf64_slurp_reloc_table,
4668   bfd_elf64_slurp_symbol_table,
4669   bfd_elf64_swap_dyn_in,
4670   bfd_elf64_swap_dyn_out,
4671   NULL,
4672   NULL,
4673   NULL,
4674   NULL
4675 };
4676
4677 #define TARGET_LITTLE_SYM       bfd_elf64_alpha_vec
4678 #define TARGET_LITTLE_NAME      "elf64-alpha"
4679 #define ELF_ARCH                bfd_arch_alpha
4680 #define ELF_MACHINE_CODE        EM_ALPHA
4681 #define ELF_MAXPAGESIZE         0x10000
4682
4683 #define bfd_elf64_bfd_link_hash_table_create \
4684   elf64_alpha_bfd_link_hash_table_create
4685
4686 #define bfd_elf64_bfd_reloc_type_lookup \
4687   elf64_alpha_bfd_reloc_type_lookup
4688 #define elf_info_to_howto \
4689   elf64_alpha_info_to_howto
4690
4691 #define bfd_elf64_mkobject \
4692   elf64_alpha_mkobject
4693 #define elf_backend_object_p \
4694   elf64_alpha_object_p
4695
4696 #define elf_backend_section_from_shdr \
4697   elf64_alpha_section_from_shdr
4698 #define elf_backend_fake_sections \
4699   elf64_alpha_fake_sections
4700
4701 #define bfd_elf64_bfd_is_local_label_name \
4702   elf64_alpha_is_local_label_name
4703 #define bfd_elf64_find_nearest_line \
4704   elf64_alpha_find_nearest_line
4705 #define bfd_elf64_bfd_relax_section \
4706   elf64_alpha_relax_section
4707
4708 #define elf_backend_add_symbol_hook \
4709   elf64_alpha_add_symbol_hook
4710 #define elf_backend_check_relocs \
4711   elf64_alpha_check_relocs
4712 #define elf_backend_create_dynamic_sections \
4713   elf64_alpha_create_dynamic_sections
4714 #define elf_backend_adjust_dynamic_symbol \
4715   elf64_alpha_adjust_dynamic_symbol
4716 #define elf_backend_always_size_sections \
4717   elf64_alpha_always_size_sections
4718 #define elf_backend_size_dynamic_sections \
4719   elf64_alpha_size_dynamic_sections
4720 #define elf_backend_relocate_section \
4721   elf64_alpha_relocate_section
4722 #define elf_backend_finish_dynamic_symbol \
4723   elf64_alpha_finish_dynamic_symbol
4724 #define elf_backend_finish_dynamic_sections \
4725   elf64_alpha_finish_dynamic_sections
4726 #define bfd_elf64_bfd_final_link \
4727   elf64_alpha_final_link
4728
4729 #define elf_backend_ecoff_debug_swap \
4730   &elf64_alpha_ecoff_debug_swap
4731
4732 #define elf_backend_size_info \
4733   alpha_elf_size_info
4734
4735 /*
4736  * A few constants that determine how the .plt section is set up.
4737  */
4738 #define elf_backend_want_got_plt 0
4739 #define elf_backend_plt_readonly 0
4740 #define elf_backend_want_plt_sym 1
4741 #define elf_backend_got_header_size 0
4742 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4743
4744 #include "elf64-target.h"