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         }
3316     }
3317
3318   return true;
3319 }
3320
3321 /* Relocate an Alpha ELF section.  */
3322
3323 static boolean
3324 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3325                               contents, relocs, local_syms, local_sections)
3326      bfd *output_bfd;
3327      struct bfd_link_info *info;
3328      bfd *input_bfd;
3329      asection *input_section;
3330      bfd_byte *contents;
3331      Elf_Internal_Rela *relocs;
3332      Elf_Internal_Sym *local_syms;
3333      asection **local_sections;
3334 {
3335   Elf_Internal_Shdr *symtab_hdr;
3336   Elf_Internal_Rela *rel;
3337   Elf_Internal_Rela *relend;
3338   asection *sec, *sgot, *srel, *srelgot;
3339   bfd *dynobj, *gotobj;
3340   bfd_vma gp;
3341
3342   srelgot = srel = NULL;
3343   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3344   dynobj = elf_hash_table (info)->dynobj;
3345   if (dynobj)
3346     {
3347       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3348     }
3349
3350   /* Find the gp value for this input bfd.  */
3351   sgot = NULL;
3352   gp = 0;
3353   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3354   if (gotobj)
3355     {
3356       sgot = alpha_elf_tdata (gotobj)->got;
3357       gp = _bfd_get_gp_value (gotobj);
3358       if (gp == 0)
3359         {
3360           gp = (sgot->output_section->vma
3361                 + sgot->output_offset
3362                 + 0x8000);
3363           _bfd_set_gp_value (gotobj, gp);
3364         }
3365     }
3366
3367   rel = relocs;
3368   relend = relocs + input_section->reloc_count;
3369   for (; rel < relend; rel++)
3370     {
3371       int r_type;
3372       reloc_howto_type *howto;
3373       unsigned long r_symndx;
3374       struct alpha_elf_link_hash_entry *h;
3375       Elf_Internal_Sym *sym;
3376       bfd_vma relocation;
3377       bfd_vma addend;
3378       bfd_reloc_status_type r;
3379
3380       r_type = ELF64_R_TYPE(rel->r_info);
3381       if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3382         {
3383           bfd_set_error (bfd_error_bad_value);
3384           return false;
3385         }
3386       howto = elf64_alpha_howto_table + r_type;
3387
3388       r_symndx = ELF64_R_SYM(rel->r_info);
3389
3390       if (info->relocateable)
3391         {
3392           /* This is a relocateable link.  We don't have to change
3393              anything, unless the reloc is against a section symbol,
3394              in which case we have to adjust according to where the
3395              section symbol winds up in the output section.  */
3396
3397           /* The symbol associated with GPDISP and LITUSE is
3398              immaterial.  Only the addend is significant.  */
3399           if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3400             continue;
3401
3402           if (r_symndx < symtab_hdr->sh_info)
3403             {
3404               sym = local_syms + r_symndx;
3405               if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3406                 {
3407                   sec = local_sections[r_symndx];
3408                   rel->r_addend += sec->output_offset + sym->st_value;
3409                 }
3410             }
3411
3412           continue;
3413         }
3414
3415       /* This is a final link.  */
3416
3417       h = NULL;
3418       sym = NULL;
3419       sec = NULL;
3420
3421       if (r_symndx < symtab_hdr->sh_info)
3422         {
3423           sym = local_syms + r_symndx;
3424           sec = local_sections[r_symndx];
3425           relocation = (sec->output_section->vma
3426                         + sec->output_offset
3427                         + sym->st_value);
3428         }
3429       else
3430         {
3431           h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3432
3433           while (h->root.root.type == bfd_link_hash_indirect
3434                  || h->root.root.type == bfd_link_hash_warning)
3435             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3436
3437           if (h->root.root.type == bfd_link_hash_defined
3438               || h->root.root.type == bfd_link_hash_defweak)
3439             {
3440               sec = h->root.root.u.def.section;
3441
3442 #if rth_notdef
3443               if ((r_type == R_ALPHA_LITERAL
3444                    && elf_hash_table(info)->dynamic_sections_created
3445                    && (!info->shared
3446                        || !info->symbolic
3447                        || !(h->root.elf_link_hash_flags
3448                             & ELF_LINK_HASH_DEF_REGULAR)))
3449                   || (info->shared
3450                       && (!info->symbolic
3451                           || !(h->root.elf_link_hash_flags
3452                                & ELF_LINK_HASH_DEF_REGULAR))
3453                       && (input_section->flags & SEC_ALLOC)
3454                       && (r_type == R_ALPHA_REFLONG
3455                           || r_type == R_ALPHA_REFQUAD
3456                           || r_type == R_ALPHA_LITERAL)))
3457                 {
3458                   /* In these cases, we don't need the relocation value.
3459                      We check specially because in some obscure cases
3460                      sec->output_section will be NULL.  */
3461                   relocation = 0;
3462                 }
3463 #else
3464               /* FIXME: Are not these obscure cases simply bugs?  Let's
3465                  get something working and come back to this.  */
3466               if (sec->output_section == NULL)
3467                 relocation = 0;
3468 #endif /* rth_notdef */
3469               else
3470                 {
3471                   relocation = (h->root.root.u.def.value
3472                                 + sec->output_section->vma
3473                                 + sec->output_offset);
3474                 }
3475             }
3476           else if (h->root.root.type == bfd_link_hash_undefweak)
3477             relocation = 0;
3478           else if (info->shared && !info->symbolic
3479                    && !info->no_undefined
3480                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3481             relocation = 0;
3482           else
3483             {
3484               if (!((*info->callbacks->undefined_symbol)
3485                     (info, h->root.root.root.string, input_bfd,
3486                      input_section, rel->r_offset,
3487                      (!info->shared || info->no_undefined
3488                       || ELF_ST_VISIBILITY (h->root.other)))))
3489                 return false;
3490               relocation = 0;
3491             }
3492         }
3493       addend = rel->r_addend;
3494
3495       switch (r_type)
3496         {
3497         case R_ALPHA_GPDISP:
3498           {
3499             bfd_byte *p_ldah, *p_lda;
3500
3501             BFD_ASSERT(gp != 0);
3502
3503             relocation = (input_section->output_section->vma
3504                           + input_section->output_offset
3505                           + rel->r_offset);
3506
3507             p_ldah = contents + rel->r_offset - input_section->vma;
3508             p_lda = p_ldah + rel->r_addend;
3509
3510             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3511                                              p_ldah, p_lda);
3512           }
3513           break;
3514
3515         case R_ALPHA_OP_PUSH:
3516         case R_ALPHA_OP_STORE:
3517         case R_ALPHA_OP_PSUB:
3518         case R_ALPHA_OP_PRSHIFT:
3519           /* We hate these silly beasts.  */
3520           abort();
3521
3522         case R_ALPHA_LITERAL:
3523           {
3524             struct alpha_elf_got_entry *gotent;
3525             boolean dynamic_symbol;
3526
3527             BFD_ASSERT(sgot != NULL);
3528             BFD_ASSERT(gp != 0);
3529
3530             if (h != NULL)
3531               {
3532                 gotent = h->got_entries;
3533                 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3534               }
3535             else
3536               {
3537                 gotent = (alpha_elf_tdata(input_bfd)->
3538                           local_got_entries[r_symndx]);
3539                 dynamic_symbol = false;
3540               }
3541
3542             BFD_ASSERT(gotent != NULL);
3543
3544             while (gotent->gotobj != gotobj || gotent->addend != addend)
3545               gotent = gotent->next;
3546
3547             BFD_ASSERT(gotent->use_count >= 1);
3548
3549             /* Initialize the .got entry's value.  */
3550             if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3551               {
3552                 bfd_put_64 (output_bfd, relocation+addend,
3553                             sgot->contents + gotent->got_offset);
3554
3555                 /* If the symbol has been forced local, output a
3556                    RELATIVE reloc, otherwise it will be handled in
3557                    finish_dynamic_symbol.  */
3558                 if (info->shared && !dynamic_symbol)
3559                   {
3560                     Elf_Internal_Rela outrel;
3561
3562                     BFD_ASSERT(srelgot != NULL);
3563
3564                     outrel.r_offset = (sgot->output_section->vma
3565                                        + sgot->output_offset
3566                                        + gotent->got_offset);
3567                     outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3568                     outrel.r_addend = 0;
3569
3570                     bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3571                                                ((Elf64_External_Rela *)
3572                                                 srelgot->contents)
3573                                                + srelgot->reloc_count++);
3574                     BFD_ASSERT (sizeof(Elf64_External_Rela)
3575                                 * srelgot->reloc_count
3576                                 <= srelgot->_cooked_size);
3577                   }
3578
3579                 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3580               }
3581
3582             /* Figure the gprel relocation.  */
3583             addend = 0;
3584             relocation = (sgot->output_section->vma
3585                           + sgot->output_offset
3586                           + gotent->got_offset);
3587             relocation -= gp;
3588           }
3589           /* overflow handled by _bfd_final_link_relocate */
3590           goto default_reloc;
3591
3592         case R_ALPHA_GPREL32:
3593         case R_ALPHA_GPRELLOW:
3594           BFD_ASSERT(gp != 0);
3595           relocation -= gp;
3596           goto default_reloc;
3597
3598         case R_ALPHA_GPRELHIGH:
3599           BFD_ASSERT(gp != 0);
3600           relocation -= gp;
3601           relocation += addend;
3602           addend = 0;
3603           relocation = (((bfd_signed_vma) relocation >> 16)
3604                         + ((relocation >> 15) & 1));
3605           goto default_reloc;
3606
3607         case R_ALPHA_BRADDR:
3608         case R_ALPHA_HINT:
3609           /* The regular PC-relative stuff measures from the start of
3610              the instruction rather than the end.  */
3611           addend -= 4;
3612           goto default_reloc;
3613
3614         case R_ALPHA_REFLONG:
3615         case R_ALPHA_REFQUAD:
3616           {
3617             Elf_Internal_Rela outrel;
3618             boolean skip;
3619
3620             /* Careful here to remember RELATIVE relocations for global
3621                variables for symbolic shared objects.  */
3622
3623             if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3624               {
3625                 BFD_ASSERT(h->root.dynindx != -1);
3626                 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3627                 outrel.r_addend = addend;
3628                 addend = 0, relocation = 0;
3629               }
3630             else if (info->shared && (input_section->flags & SEC_ALLOC))
3631               {
3632                 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3633                 outrel.r_addend = 0;
3634               }
3635             else
3636               goto default_reloc;
3637
3638             if (!srel)
3639               {
3640                 const char *name;
3641
3642                 name = (bfd_elf_string_from_elf_section
3643                         (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3644                          elf_section_data(input_section)->rel_hdr.sh_name));
3645                 BFD_ASSERT(name != NULL);
3646
3647                 srel = bfd_get_section_by_name (dynobj, name);
3648                 BFD_ASSERT(srel != NULL);
3649               }
3650
3651             skip = false;
3652
3653             if (elf_section_data (input_section)->stab_info == NULL)
3654               outrel.r_offset = rel->r_offset;
3655             else
3656               {
3657                 bfd_vma off;
3658
3659                 off = (_bfd_stab_section_offset
3660                        (output_bfd, &elf_hash_table (info)->stab_info,
3661                         input_section,
3662                         &elf_section_data (input_section)->stab_info,
3663                         rel->r_offset));
3664                 if (off == (bfd_vma) -1)
3665                   skip = true;
3666                 outrel.r_offset = off;
3667               }
3668
3669             if (! skip)
3670               outrel.r_offset += (input_section->output_section->vma
3671                                   + input_section->output_offset);
3672             else
3673               memset (&outrel, 0, sizeof outrel);
3674
3675             bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3676                                        ((Elf64_External_Rela *)
3677                                         srel->contents)
3678                                        + srel->reloc_count++);
3679             BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3680                         <= srel->_cooked_size);
3681           }
3682           goto default_reloc;
3683
3684         default:
3685         default_reloc:
3686           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3687                                         contents, rel->r_offset, relocation,
3688                                         addend);
3689           break;
3690         }
3691
3692       switch (r)
3693         {
3694         case bfd_reloc_ok:
3695           break;
3696
3697         case bfd_reloc_overflow:
3698           {
3699             const char *name;
3700
3701             if (h != NULL)
3702               name = h->root.root.root.string;
3703             else
3704               {
3705                 name = (bfd_elf_string_from_elf_section
3706                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
3707                 if (name == NULL)
3708                   return false;
3709                 if (*name == '\0')
3710                   name = bfd_section_name (input_bfd, sec);
3711               }
3712             if (! ((*info->callbacks->reloc_overflow)
3713                    (info, name, howto->name, (bfd_vma) 0,
3714                     input_bfd, input_section, rel->r_offset)))
3715               return false;
3716           }
3717           break;
3718
3719         default:
3720         case bfd_reloc_outofrange:
3721           abort ();
3722         }
3723     }
3724
3725   return true;
3726 }
3727
3728 /* Finish up dynamic symbol handling.  We set the contents of various
3729    dynamic sections here.  */
3730
3731 static boolean
3732 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3733      bfd *output_bfd;
3734      struct bfd_link_info *info;
3735      struct elf_link_hash_entry *h;
3736      Elf_Internal_Sym *sym;
3737 {
3738   bfd *dynobj = elf_hash_table(info)->dynobj;
3739
3740   if (h->plt.offset != MINUS_ONE)
3741     {
3742       /* Fill in the .plt entry for this symbol.  */
3743       asection *splt, *sgot, *srel;
3744       Elf_Internal_Rela outrel;
3745       bfd_vma got_addr, plt_addr;
3746       bfd_vma plt_index;
3747       struct alpha_elf_got_entry *gotent;
3748
3749       BFD_ASSERT (h->dynindx != -1);
3750
3751       /* The first .got entry will be updated by the .plt with the
3752          address of the target function.  */
3753       gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3754       BFD_ASSERT (gotent && gotent->addend == 0);
3755
3756       splt = bfd_get_section_by_name (dynobj, ".plt");
3757       BFD_ASSERT (splt != NULL);
3758       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3759       BFD_ASSERT (srel != NULL);
3760       sgot = alpha_elf_tdata (gotent->gotobj)->got;
3761       BFD_ASSERT (sgot != NULL);
3762
3763       got_addr = (sgot->output_section->vma
3764                   + sgot->output_offset
3765                   + gotent->got_offset);
3766       plt_addr = (splt->output_section->vma
3767                   + splt->output_offset
3768                   + h->plt.offset);
3769
3770       plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3771
3772       /* Fill in the entry in the procedure linkage table.  */
3773       {
3774         unsigned insn1, insn2, insn3;
3775
3776         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3777         insn2 = PLT_ENTRY_WORD2;
3778         insn3 = PLT_ENTRY_WORD3;
3779
3780         bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3781         bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3782         bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3783       }
3784
3785       /* Fill in the entry in the .rela.plt section.  */
3786       outrel.r_offset = got_addr;
3787       outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3788       outrel.r_addend = 0;
3789
3790       bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3791                                  ((Elf64_External_Rela *)srel->contents
3792                                   + plt_index));
3793
3794       if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3795         {
3796           /* Mark the symbol as undefined, rather than as defined in the
3797              .plt section.  Leave the value alone.  */
3798           sym->st_shndx = SHN_UNDEF;
3799         }
3800
3801       /* Fill in the entries in the .got.  */
3802       bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3803
3804       /* Subsequent .got entries will continue to bounce through the .plt.  */
3805       if (gotent->next)
3806         {
3807           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3808           BFD_ASSERT (! info->shared || srel != NULL);
3809
3810           gotent = gotent->next;
3811           do
3812             {
3813               sgot = alpha_elf_tdata(gotent->gotobj)->got;
3814               BFD_ASSERT(sgot != NULL);
3815               BFD_ASSERT(gotent->addend == 0);
3816
3817               bfd_put_64 (output_bfd, plt_addr,
3818                           sgot->contents + gotent->got_offset);
3819
3820               if (info->shared)
3821                 {
3822                   outrel.r_offset = (sgot->output_section->vma
3823                                      + sgot->output_offset
3824                                      + gotent->got_offset);
3825                   outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3826                   outrel.r_addend = 0;
3827
3828                   bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3829                                              ((Elf64_External_Rela *)
3830                                               srel->contents)
3831                                              + srel->reloc_count++);
3832                   BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3833                               <= srel->_cooked_size);
3834                 }
3835
3836               gotent = gotent->next;
3837             }
3838           while (gotent != NULL);
3839         }
3840     }
3841   else if (alpha_elf_dynamic_symbol_p (h, info))
3842     {
3843       /* Fill in the dynamic relocations for this symbol's .got entries.  */
3844       asection *srel;
3845       Elf_Internal_Rela outrel;
3846       struct alpha_elf_got_entry *gotent;
3847
3848       srel = bfd_get_section_by_name (dynobj, ".rela.got");
3849       BFD_ASSERT (srel != NULL);
3850
3851       outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3852       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3853            gotent != NULL;
3854            gotent = gotent->next)
3855         {
3856           asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3857           outrel.r_offset = (sgot->output_section->vma
3858                              + sgot->output_offset
3859                              + gotent->got_offset);
3860           outrel.r_addend = gotent->addend;
3861
3862           bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3863                                      ((Elf64_External_Rela *)srel->contents
3864                                       + srel->reloc_count++));
3865           BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3866                       <= srel->_cooked_size);
3867         }
3868     }
3869
3870   /* Mark some specially defined symbols as absolute.  */
3871   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3872       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3873       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3874     sym->st_shndx = SHN_ABS;
3875
3876   return true;
3877 }
3878
3879 /* Finish up the dynamic sections.  */
3880
3881 static boolean
3882 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3883      bfd *output_bfd;
3884      struct bfd_link_info *info;
3885 {
3886   bfd *dynobj;
3887   asection *sdyn;
3888
3889   dynobj = elf_hash_table (info)->dynobj;
3890   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3891
3892   if (elf_hash_table (info)->dynamic_sections_created)
3893     {
3894       asection *splt;
3895       Elf64_External_Dyn *dyncon, *dynconend;
3896
3897       splt = bfd_get_section_by_name (dynobj, ".plt");
3898       BFD_ASSERT (splt != NULL && sdyn != NULL);
3899
3900       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3901       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3902       for (; dyncon < dynconend; dyncon++)
3903         {
3904           Elf_Internal_Dyn dyn;
3905           const char *name;
3906           asection *s;
3907
3908           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3909
3910           switch (dyn.d_tag)
3911             {
3912             case DT_PLTGOT:
3913               name = ".plt";
3914               goto get_vma;
3915             case DT_PLTRELSZ:
3916               name = ".rela.plt";
3917               goto get_size;
3918             case DT_JMPREL:
3919               name = ".rela.plt";
3920               goto get_vma;
3921
3922             case DT_RELASZ:
3923               /* My interpretation of the TIS v1.1 ELF document indicates
3924                  that RELASZ should not include JMPREL.  This is not what
3925                  the rest of the BFD does.  It is, however, what the
3926                  glibc ld.so wants.  Do this fixup here until we found
3927                  out who is right.  */
3928               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3929               if (s)
3930                 {
3931                   dyn.d_un.d_val -=
3932                     (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3933                 }
3934               break;
3935
3936             get_vma:
3937               s = bfd_get_section_by_name (output_bfd, name);
3938               dyn.d_un.d_ptr = (s ? s->vma : 0);
3939               break;
3940
3941             get_size:
3942               s = bfd_get_section_by_name (output_bfd, name);
3943               dyn.d_un.d_val =
3944                 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3945               break;
3946             }
3947
3948           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3949         }
3950
3951       /* Initialize the PLT0 entry */
3952       if (splt->_raw_size > 0)
3953         {
3954           bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3955           bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3956           bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3957           bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3958
3959           /* The next two words will be filled in by ld.so */
3960           bfd_put_64 (output_bfd, 0, splt->contents + 16);
3961           bfd_put_64 (output_bfd, 0, splt->contents + 24);
3962
3963           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3964             PLT_HEADER_SIZE;
3965         }
3966     }
3967
3968   return true;
3969 }
3970
3971 /* We need to use a special link routine to handle the .reginfo and
3972    the .mdebug sections.  We need to merge all instances of these
3973    sections together, not write them all out sequentially.  */
3974
3975 static boolean
3976 elf64_alpha_final_link (abfd, info)
3977      bfd *abfd;
3978      struct bfd_link_info *info;
3979 {
3980   asection *o;
3981   struct bfd_link_order *p;
3982   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3983   struct ecoff_debug_info debug;
3984   const struct ecoff_debug_swap *swap
3985     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3986   HDRR *symhdr = &debug.symbolic_header;
3987   PTR mdebug_handle = NULL;
3988
3989 #if 0
3990               if (++ngots == 2)
3991                 {
3992                   (*info->callbacks->warning)
3993                     (info, _("using multiple gp values"), (char *) NULL,
3994                      output_bfd, (asection *) NULL, (bfd_vma) 0);
3995                 }
3996 #endif
3997
3998   /* Go through the sections and collect the .reginfo and .mdebug
3999      information.  */
4000   reginfo_sec = NULL;
4001   mdebug_sec = NULL;
4002   gptab_data_sec = NULL;
4003   gptab_bss_sec = NULL;
4004   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4005     {
4006 #ifdef ERIC_neverdef
4007       if (strcmp (o->name, ".reginfo") == 0)
4008         {
4009           memset (&reginfo, 0, sizeof reginfo);
4010
4011           /* We have found the .reginfo section in the output file.
4012              Look through all the link_orders comprising it and merge
4013              the information together.  */
4014           for (p = o->link_order_head;
4015                p != (struct bfd_link_order *) NULL;
4016                p = p->next)
4017             {
4018               asection *input_section;
4019               bfd *input_bfd;
4020               Elf64_External_RegInfo ext;
4021               Elf64_RegInfo sub;
4022
4023               if (p->type != bfd_indirect_link_order)
4024                 {
4025                   if (p->type == bfd_fill_link_order)
4026                     continue;
4027                   abort ();
4028                 }
4029
4030               input_section = p->u.indirect.section;
4031               input_bfd = input_section->owner;
4032
4033               /* The linker emulation code has probably clobbered the
4034                  size to be zero bytes.  */
4035               if (input_section->_raw_size == 0)
4036                 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4037
4038               if (! bfd_get_section_contents (input_bfd, input_section,
4039                                               (PTR) &ext,
4040                                               (file_ptr) 0,
4041                                               sizeof ext))
4042                 return false;
4043
4044               bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4045
4046               reginfo.ri_gprmask |= sub.ri_gprmask;
4047               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4048               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4049               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4050               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4051
4052               /* ri_gp_value is set by the function
4053                  alpha_elf_section_processing when the section is
4054                  finally written out.  */
4055
4056               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4057                  elf_link_input_bfd ignores this section.  */
4058               input_section->flags &=~ SEC_HAS_CONTENTS;
4059             }
4060
4061           /* Force the section size to the value we want.  */
4062           o->_raw_size = sizeof (Elf64_External_RegInfo);
4063
4064           /* Skip this section later on (I don't think this currently
4065              matters, but someday it might).  */
4066           o->link_order_head = (struct bfd_link_order *) NULL;
4067
4068           reginfo_sec = o;
4069         }
4070 #endif
4071
4072       if (strcmp (o->name, ".mdebug") == 0)
4073         {
4074           struct extsym_info einfo;
4075
4076           /* We have found the .mdebug section in the output file.
4077              Look through all the link_orders comprising it and merge
4078              the information together.  */
4079           symhdr->magic = swap->sym_magic;
4080           /* FIXME: What should the version stamp be?  */
4081           symhdr->vstamp = 0;
4082           symhdr->ilineMax = 0;
4083           symhdr->cbLine = 0;
4084           symhdr->idnMax = 0;
4085           symhdr->ipdMax = 0;
4086           symhdr->isymMax = 0;
4087           symhdr->ioptMax = 0;
4088           symhdr->iauxMax = 0;
4089           symhdr->issMax = 0;
4090           symhdr->issExtMax = 0;
4091           symhdr->ifdMax = 0;
4092           symhdr->crfd = 0;
4093           symhdr->iextMax = 0;
4094
4095           /* We accumulate the debugging information itself in the
4096              debug_info structure.  */
4097           debug.line = NULL;
4098           debug.external_dnr = NULL;
4099           debug.external_pdr = NULL;
4100           debug.external_sym = NULL;
4101           debug.external_opt = NULL;
4102           debug.external_aux = NULL;
4103           debug.ss = NULL;
4104           debug.ssext = debug.ssext_end = NULL;
4105           debug.external_fdr = NULL;
4106           debug.external_rfd = NULL;
4107           debug.external_ext = debug.external_ext_end = NULL;
4108
4109           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4110           if (mdebug_handle == (PTR) NULL)
4111             return false;
4112
4113           if (1)
4114             {
4115               asection *s;
4116               EXTR esym;
4117               bfd_vma last;
4118               unsigned int i;
4119               static const char * const name[] =
4120                 {
4121                   ".text", ".init", ".fini", ".data",
4122                   ".rodata", ".sdata", ".sbss", ".bss"
4123                 };
4124               static const int sc[] = { scText, scInit, scFini, scData,
4125                                           scRData, scSData, scSBss, scBss };
4126
4127               esym.jmptbl = 0;
4128               esym.cobol_main = 0;
4129               esym.weakext = 0;
4130               esym.reserved = 0;
4131               esym.ifd = ifdNil;
4132               esym.asym.iss = issNil;
4133               esym.asym.st = stLocal;
4134               esym.asym.reserved = 0;
4135               esym.asym.index = indexNil;
4136               for (i = 0; i < 8; i++)
4137                 {
4138                   esym.asym.sc = sc[i];
4139                   s = bfd_get_section_by_name (abfd, name[i]);
4140                   if (s != NULL)
4141                     {
4142                       esym.asym.value = s->vma;
4143                       last = s->vma + s->_raw_size;
4144                     }
4145                   else
4146                     esym.asym.value = last;
4147
4148                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4149                                                       name[i], &esym))
4150                     return false;
4151                 }
4152             }
4153
4154           for (p = o->link_order_head;
4155                p != (struct bfd_link_order *) NULL;
4156                p = p->next)
4157             {
4158               asection *input_section;
4159               bfd *input_bfd;
4160               const struct ecoff_debug_swap *input_swap;
4161               struct ecoff_debug_info input_debug;
4162               char *eraw_src;
4163               char *eraw_end;
4164
4165               if (p->type != bfd_indirect_link_order)
4166                 {
4167                   if (p->type == bfd_fill_link_order)
4168                     continue;
4169                   abort ();
4170                 }
4171
4172               input_section = p->u.indirect.section;
4173               input_bfd = input_section->owner;
4174
4175               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4176                   || (get_elf_backend_data (input_bfd)
4177                       ->elf_backend_ecoff_debug_swap) == NULL)
4178                 {
4179                   /* I don't know what a non ALPHA ELF bfd would be
4180                      doing with a .mdebug section, but I don't really
4181                      want to deal with it.  */
4182                   continue;
4183                 }
4184
4185               input_swap = (get_elf_backend_data (input_bfd)
4186                             ->elf_backend_ecoff_debug_swap);
4187
4188               BFD_ASSERT (p->size == input_section->_raw_size);
4189
4190               /* The ECOFF linking code expects that we have already
4191                  read in the debugging information and set up an
4192                  ecoff_debug_info structure, so we do that now.  */
4193               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4194                                                 &input_debug))
4195                 return false;
4196
4197               if (! (bfd_ecoff_debug_accumulate
4198                      (mdebug_handle, abfd, &debug, swap, input_bfd,
4199                       &input_debug, input_swap, info)))
4200                 return false;
4201
4202               /* Loop through the external symbols.  For each one with
4203                  interesting information, try to find the symbol in
4204                  the linker global hash table and save the information
4205                  for the output external symbols.  */
4206               eraw_src = input_debug.external_ext;
4207               eraw_end = (eraw_src
4208                           + (input_debug.symbolic_header.iextMax
4209                              * input_swap->external_ext_size));
4210               for (;
4211                    eraw_src < eraw_end;
4212                    eraw_src += input_swap->external_ext_size)
4213                 {
4214                   EXTR ext;
4215                   const char *name;
4216                   struct alpha_elf_link_hash_entry *h;
4217
4218                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4219                   if (ext.asym.sc == scNil
4220                       || ext.asym.sc == scUndefined
4221                       || ext.asym.sc == scSUndefined)
4222                     continue;
4223
4224                   name = input_debug.ssext + ext.asym.iss;
4225                   h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4226                                                   name, false, false, true);
4227                   if (h == NULL || h->esym.ifd != -2)
4228                     continue;
4229
4230                   if (ext.ifd != -1)
4231                     {
4232                       BFD_ASSERT (ext.ifd
4233                                   < input_debug.symbolic_header.ifdMax);
4234                       ext.ifd = input_debug.ifdmap[ext.ifd];
4235                     }
4236
4237                   h->esym = ext;
4238                 }
4239
4240               /* Free up the information we just read.  */
4241               free (input_debug.line);
4242               free (input_debug.external_dnr);
4243               free (input_debug.external_pdr);
4244               free (input_debug.external_sym);
4245               free (input_debug.external_opt);
4246               free (input_debug.external_aux);
4247               free (input_debug.ss);
4248               free (input_debug.ssext);
4249               free (input_debug.external_fdr);
4250               free (input_debug.external_rfd);
4251               free (input_debug.external_ext);
4252
4253               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4254                  elf_link_input_bfd ignores this section.  */
4255               input_section->flags &=~ SEC_HAS_CONTENTS;
4256             }
4257
4258 #ifdef ERIC_neverdef
4259           if (info->shared)
4260             {
4261               /* Create .rtproc section.  */
4262               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4263               if (rtproc_sec == NULL)
4264                 {
4265                   flagword flags = (SEC_HAS_CONTENTS
4266                                     | SEC_IN_MEMORY
4267                                     | SEC_LINKER_CREATED
4268                                     | SEC_READONLY);
4269
4270                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
4271                   if (rtproc_sec == NULL
4272                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4273                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4274                     return false;
4275                 }
4276
4277               if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4278                                                      info, rtproc_sec, &debug))
4279                 return false;
4280             }
4281 #endif
4282
4283
4284           /* Build the external symbol information.  */
4285           einfo.abfd = abfd;
4286           einfo.info = info;
4287           einfo.debug = &debug;
4288           einfo.swap = swap;
4289           einfo.failed = false;
4290           elf_link_hash_traverse (elf_hash_table (info),
4291                                   elf64_alpha_output_extsym,
4292                                   (PTR) &einfo);
4293           if (einfo.failed)
4294             return false;
4295
4296           /* Set the size of the .mdebug section.  */
4297           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4298
4299           /* Skip this section later on (I don't think this currently
4300              matters, but someday it might).  */
4301           o->link_order_head = (struct bfd_link_order *) NULL;
4302
4303           mdebug_sec = o;
4304         }
4305
4306 #ifdef ERIC_neverdef
4307       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4308         {
4309           const char *subname;
4310           unsigned int c;
4311           Elf64_gptab *tab;
4312           Elf64_External_gptab *ext_tab;
4313           unsigned int i;
4314
4315           /* The .gptab.sdata and .gptab.sbss sections hold
4316              information describing how the small data area would
4317              change depending upon the -G switch.  These sections
4318              not used in executables files.  */
4319           if (! info->relocateable)
4320             {
4321               asection **secpp;
4322
4323               for (p = o->link_order_head;
4324                    p != (struct bfd_link_order *) NULL;
4325                    p = p->next)
4326                 {
4327                   asection *input_section;
4328
4329                   if (p->type != bfd_indirect_link_order)
4330                     {
4331                       if (p->type == bfd_fill_link_order)
4332                         continue;
4333                       abort ();
4334                     }
4335
4336                   input_section = p->u.indirect.section;
4337
4338                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
4339                      elf_link_input_bfd ignores this section.  */
4340                   input_section->flags &=~ SEC_HAS_CONTENTS;
4341                 }
4342
4343               /* Skip this section later on (I don't think this
4344                  currently matters, but someday it might).  */
4345               o->link_order_head = (struct bfd_link_order *) NULL;
4346
4347               /* Really remove the section.  */
4348               for (secpp = &abfd->sections;
4349                    *secpp != o;
4350                    secpp = &(*secpp)->next)
4351                 ;
4352               *secpp = (*secpp)->next;
4353               --abfd->section_count;
4354
4355               continue;
4356             }
4357
4358           /* There is one gptab for initialized data, and one for
4359              uninitialized data.  */
4360           if (strcmp (o->name, ".gptab.sdata") == 0)
4361             gptab_data_sec = o;
4362           else if (strcmp (o->name, ".gptab.sbss") == 0)
4363             gptab_bss_sec = o;
4364           else
4365             {
4366               (*_bfd_error_handler)
4367                 (_("%s: illegal section name `%s'"),
4368                  bfd_get_filename (abfd), o->name);
4369               bfd_set_error (bfd_error_nonrepresentable_section);
4370               return false;
4371             }
4372
4373           /* The linker script always combines .gptab.data and
4374              .gptab.sdata into .gptab.sdata, and likewise for
4375              .gptab.bss and .gptab.sbss.  It is possible that there is
4376              no .sdata or .sbss section in the output file, in which
4377              case we must change the name of the output section.  */
4378           subname = o->name + sizeof ".gptab" - 1;
4379           if (bfd_get_section_by_name (abfd, subname) == NULL)
4380             {
4381               if (o == gptab_data_sec)
4382                 o->name = ".gptab.data";
4383               else
4384                 o->name = ".gptab.bss";
4385               subname = o->name + sizeof ".gptab" - 1;
4386               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4387             }
4388
4389           /* Set up the first entry.  */
4390           c = 1;
4391           tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4392           if (tab == NULL)
4393             return false;
4394           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4395           tab[0].gt_header.gt_unused = 0;
4396
4397           /* Combine the input sections.  */
4398           for (p = o->link_order_head;
4399                p != (struct bfd_link_order *) NULL;
4400                p = p->next)
4401             {
4402               asection *input_section;
4403               bfd *input_bfd;
4404               bfd_size_type size;
4405               unsigned long last;
4406               bfd_size_type gpentry;
4407
4408               if (p->type != bfd_indirect_link_order)
4409                 {
4410                   if (p->type == bfd_fill_link_order)
4411                     continue;
4412                   abort ();
4413                 }
4414
4415               input_section = p->u.indirect.section;
4416               input_bfd = input_section->owner;
4417
4418               /* Combine the gptab entries for this input section one
4419                  by one.  We know that the input gptab entries are
4420                  sorted by ascending -G value.  */
4421               size = bfd_section_size (input_bfd, input_section);
4422               last = 0;
4423               for (gpentry = sizeof (Elf64_External_gptab);
4424                    gpentry < size;
4425                    gpentry += sizeof (Elf64_External_gptab))
4426                 {
4427                   Elf64_External_gptab ext_gptab;
4428                   Elf64_gptab int_gptab;
4429                   unsigned long val;
4430                   unsigned long add;
4431                   boolean exact;
4432                   unsigned int look;
4433
4434                   if (! (bfd_get_section_contents
4435                          (input_bfd, input_section, (PTR) &ext_gptab,
4436                           gpentry, sizeof (Elf64_External_gptab))))
4437                     {
4438                       free (tab);
4439                       return false;
4440                     }
4441
4442                   bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4443                                                 &int_gptab);
4444                   val = int_gptab.gt_entry.gt_g_value;
4445                   add = int_gptab.gt_entry.gt_bytes - last;
4446
4447                   exact = false;
4448                   for (look = 1; look < c; look++)
4449                     {
4450                       if (tab[look].gt_entry.gt_g_value >= val)
4451                         tab[look].gt_entry.gt_bytes += add;
4452
4453                       if (tab[look].gt_entry.gt_g_value == val)
4454                         exact = true;
4455                     }
4456
4457                   if (! exact)
4458                     {
4459                       Elf64_gptab *new_tab;
4460                       unsigned int max;
4461
4462                       /* We need a new table entry.  */
4463                       new_tab = ((Elf64_gptab *)
4464                                  bfd_realloc ((PTR) tab,
4465                                               (c + 1) * sizeof (Elf64_gptab)));
4466                       if (new_tab == NULL)
4467                         {
4468                           free (tab);
4469                           return false;
4470                         }
4471                       tab = new_tab;
4472                       tab[c].gt_entry.gt_g_value = val;
4473                       tab[c].gt_entry.gt_bytes = add;
4474
4475                       /* Merge in the size for the next smallest -G
4476                          value, since that will be implied by this new
4477                          value.  */
4478                       max = 0;
4479                       for (look = 1; look < c; look++)
4480                         {
4481                           if (tab[look].gt_entry.gt_g_value < val
4482                               && (max == 0
4483                                   || (tab[look].gt_entry.gt_g_value
4484                                       > tab[max].gt_entry.gt_g_value)))
4485                             max = look;
4486                         }
4487                       if (max != 0)
4488                         tab[c].gt_entry.gt_bytes +=
4489                           tab[max].gt_entry.gt_bytes;
4490
4491                       ++c;
4492                     }
4493
4494                   last = int_gptab.gt_entry.gt_bytes;
4495                 }
4496
4497               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4498                  elf_link_input_bfd ignores this section.  */
4499               input_section->flags &=~ SEC_HAS_CONTENTS;
4500             }
4501
4502           /* The table must be sorted by -G value.  */
4503           if (c > 2)
4504             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4505
4506           /* Swap out the table.  */
4507           ext_tab = ((Elf64_External_gptab *)
4508                      bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4509           if (ext_tab == NULL)
4510             {
4511               free (tab);
4512               return false;
4513             }
4514
4515           for (i = 0; i < c; i++)
4516             bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4517           free (tab);
4518
4519           o->_raw_size = c * sizeof (Elf64_External_gptab);
4520           o->contents = (bfd_byte *) ext_tab;
4521
4522           /* Skip this section later on (I don't think this currently
4523              matters, but someday it might).  */
4524           o->link_order_head = (struct bfd_link_order *) NULL;
4525         }
4526 #endif
4527
4528     }
4529
4530   /* Invoke the regular ELF backend linker to do all the work.  */
4531   if (! bfd_elf64_bfd_final_link (abfd, info))
4532     return false;
4533
4534   /* Now write out the computed sections.  */
4535
4536   /* The .got subsections...  */
4537   {
4538     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4539     for (i = alpha_elf_hash_table(info)->got_list;
4540          i != NULL;
4541          i = alpha_elf_tdata(i)->got_link_next)
4542       {
4543         asection *sgot;
4544
4545         /* elf_bfd_final_link already did everything in dynobj.  */
4546         if (i == dynobj)
4547           continue;
4548
4549         sgot = alpha_elf_tdata(i)->got;
4550         if (! bfd_set_section_contents (abfd, sgot->output_section,
4551                                         sgot->contents, sgot->output_offset,
4552                                         sgot->_raw_size))
4553           return false;
4554       }
4555   }
4556
4557 #ifdef ERIC_neverdef
4558   if (reginfo_sec != (asection *) NULL)
4559     {
4560       Elf64_External_RegInfo ext;
4561
4562       bfd_alpha_elf64_swap_reginfo_out (abfd, &reginfo, &ext);
4563       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4564                                       (file_ptr) 0, sizeof ext))
4565         return false;
4566     }
4567 #endif
4568
4569   if (mdebug_sec != (asection *) NULL)
4570     {
4571       BFD_ASSERT (abfd->output_has_begun);
4572       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4573                                                swap, info,
4574                                                mdebug_sec->filepos))
4575         return false;
4576
4577       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4578     }
4579
4580   if (gptab_data_sec != (asection *) NULL)
4581     {
4582       if (! bfd_set_section_contents (abfd, gptab_data_sec,
4583                                       gptab_data_sec->contents,
4584                                       (file_ptr) 0,
4585                                       gptab_data_sec->_raw_size))
4586         return false;
4587     }
4588
4589   if (gptab_bss_sec != (asection *) NULL)
4590     {
4591       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4592                                       gptab_bss_sec->contents,
4593                                       (file_ptr) 0,
4594                                       gptab_bss_sec->_raw_size))
4595         return false;
4596     }
4597
4598   return true;
4599 }
4600 \f
4601 /* ECOFF swapping routines.  These are used when dealing with the
4602    .mdebug section, which is in the ECOFF debugging format.  Copied
4603    from elf32-mips.c. */
4604 static const struct ecoff_debug_swap
4605 elf64_alpha_ecoff_debug_swap =
4606 {
4607   /* Symbol table magic number.  */
4608   magicSym2,
4609   /* Alignment of debugging information.  E.g., 4.  */
4610   8,
4611   /* Sizes of external symbolic information.  */
4612   sizeof (struct hdr_ext),
4613   sizeof (struct dnr_ext),
4614   sizeof (struct pdr_ext),
4615   sizeof (struct sym_ext),
4616   sizeof (struct opt_ext),
4617   sizeof (struct fdr_ext),
4618   sizeof (struct rfd_ext),
4619   sizeof (struct ext_ext),
4620   /* Functions to swap in external symbolic data.  */
4621   ecoff_swap_hdr_in,
4622   ecoff_swap_dnr_in,
4623   ecoff_swap_pdr_in,
4624   ecoff_swap_sym_in,
4625   ecoff_swap_opt_in,
4626   ecoff_swap_fdr_in,
4627   ecoff_swap_rfd_in,
4628   ecoff_swap_ext_in,
4629   _bfd_ecoff_swap_tir_in,
4630   _bfd_ecoff_swap_rndx_in,
4631   /* Functions to swap out external symbolic data.  */
4632   ecoff_swap_hdr_out,
4633   ecoff_swap_dnr_out,
4634   ecoff_swap_pdr_out,
4635   ecoff_swap_sym_out,
4636   ecoff_swap_opt_out,
4637   ecoff_swap_fdr_out,
4638   ecoff_swap_rfd_out,
4639   ecoff_swap_ext_out,
4640   _bfd_ecoff_swap_tir_out,
4641   _bfd_ecoff_swap_rndx_out,
4642   /* Function to read in symbolic data.  */
4643   elf64_alpha_read_ecoff_info
4644 };
4645 \f
4646 #define TARGET_LITTLE_SYM       bfd_elf64_alpha_vec
4647 #define TARGET_LITTLE_NAME      "elf64-alpha"
4648 #define ELF_ARCH                bfd_arch_alpha
4649 #define ELF_MACHINE_CODE        EM_ALPHA
4650 #define ELF_MAXPAGESIZE         0x10000
4651
4652 #define bfd_elf64_bfd_link_hash_table_create \
4653   elf64_alpha_bfd_link_hash_table_create
4654
4655 #define bfd_elf64_bfd_reloc_type_lookup \
4656   elf64_alpha_bfd_reloc_type_lookup
4657 #define elf_info_to_howto \
4658   elf64_alpha_info_to_howto
4659
4660 #define bfd_elf64_mkobject \
4661   elf64_alpha_mkobject
4662 #define elf_backend_object_p \
4663   elf64_alpha_object_p
4664
4665 #define elf_backend_section_from_shdr \
4666   elf64_alpha_section_from_shdr
4667 #define elf_backend_fake_sections \
4668   elf64_alpha_fake_sections
4669
4670 #define bfd_elf64_bfd_is_local_label_name \
4671   elf64_alpha_is_local_label_name
4672 #define bfd_elf64_find_nearest_line \
4673   elf64_alpha_find_nearest_line
4674 #define bfd_elf64_bfd_relax_section \
4675   elf64_alpha_relax_section
4676
4677 #define elf_backend_add_symbol_hook \
4678   elf64_alpha_add_symbol_hook
4679 #define elf_backend_check_relocs \
4680   elf64_alpha_check_relocs
4681 #define elf_backend_create_dynamic_sections \
4682   elf64_alpha_create_dynamic_sections
4683 #define elf_backend_adjust_dynamic_symbol \
4684   elf64_alpha_adjust_dynamic_symbol
4685 #define elf_backend_always_size_sections \
4686   elf64_alpha_always_size_sections
4687 #define elf_backend_size_dynamic_sections \
4688   elf64_alpha_size_dynamic_sections
4689 #define elf_backend_relocate_section \
4690   elf64_alpha_relocate_section
4691 #define elf_backend_finish_dynamic_symbol \
4692   elf64_alpha_finish_dynamic_symbol
4693 #define elf_backend_finish_dynamic_sections \
4694   elf64_alpha_finish_dynamic_sections
4695 #define bfd_elf64_bfd_final_link \
4696   elf64_alpha_final_link
4697
4698 #define elf_backend_ecoff_debug_swap \
4699   &elf64_alpha_ecoff_debug_swap
4700
4701 /*
4702  * A few constants that determine how the .plt section is set up.
4703  */
4704 #define elf_backend_want_got_plt 0
4705 #define elf_backend_plt_readonly 0
4706 #define elf_backend_want_plt_sym 1
4707 #define elf_backend_got_header_size 0
4708 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4709
4710 #include "elf64-target.h"