bfd/elf64-alpha.c

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