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_vma high_address;
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   high_address = bfd_get_section_limit (abfd, input_section);
1050   if (reloc_entry->address > high_address
1051       || reloc_entry->address + reloc_entry->addend > high_address)
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        ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
1261         info->abfd, info->sec,
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        ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
1574         info->abfd, info->sec,
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.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->def_regular = 1;
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->def_regular = 1;
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.def_dynamic || h->root.ref_dynamic)
2745            && !h->root.def_regular
2746            && !h->root.ref_regular)
2747     strip = TRUE;
2748   else if (einfo->info->strip == strip_all
2749            || (einfo->info->strip == strip_some
2750                && bfd_hash_lookup (einfo->info->keep_hash,
2751                                    h->root.root.root.string,
2752                                    FALSE, FALSE) == NULL))
2753     strip = TRUE;
2754   else
2755     strip = FALSE;
2756
2757   if (strip)
2758     return TRUE;
2759
2760   if (h->esym.ifd == -2)
2761     {
2762       h->esym.jmptbl = 0;
2763       h->esym.cobol_main = 0;
2764       h->esym.weakext = 0;
2765       h->esym.reserved = 0;
2766       h->esym.ifd = ifdNil;
2767       h->esym.asym.value = 0;
2768       h->esym.asym.st = stGlobal;
2769
2770       if (h->root.root.type != bfd_link_hash_defined
2771           && h->root.root.type != bfd_link_hash_defweak)
2772         h->esym.asym.sc = scAbs;
2773       else
2774         {
2775           const char *name;
2776
2777           sec = h->root.root.u.def.section;
2778           output_section = sec->output_section;
2779
2780           /* When making a shared library and symbol h is the one from
2781              the another shared library, OUTPUT_SECTION may be null.  */
2782           if (output_section == NULL)
2783             h->esym.asym.sc = scUndefined;
2784           else
2785             {
2786               name = bfd_section_name (output_section->owner, output_section);
2787
2788               if (strcmp (name, ".text") == 0)
2789                 h->esym.asym.sc = scText;
2790               else if (strcmp (name, ".data") == 0)
2791                 h->esym.asym.sc = scData;
2792               else if (strcmp (name, ".sdata") == 0)
2793                 h->esym.asym.sc = scSData;
2794               else if (strcmp (name, ".rodata") == 0
2795                        || strcmp (name, ".rdata") == 0)
2796                 h->esym.asym.sc = scRData;
2797               else if (strcmp (name, ".bss") == 0)
2798                 h->esym.asym.sc = scBss;
2799               else if (strcmp (name, ".sbss") == 0)
2800                 h->esym.asym.sc = scSBss;
2801               else if (strcmp (name, ".init") == 0)
2802                 h->esym.asym.sc = scInit;
2803               else if (strcmp (name, ".fini") == 0)
2804                 h->esym.asym.sc = scFini;
2805               else
2806                 h->esym.asym.sc = scAbs;
2807             }
2808         }
2809
2810       h->esym.asym.reserved = 0;
2811       h->esym.asym.index = indexNil;
2812     }
2813
2814   if (h->root.root.type == bfd_link_hash_common)
2815     h->esym.asym.value = h->root.root.u.c.size;
2816   else if (h->root.root.type == bfd_link_hash_defined
2817            || h->root.root.type == bfd_link_hash_defweak)
2818     {
2819       if (h->esym.asym.sc == scCommon)
2820         h->esym.asym.sc = scBss;
2821       else if (h->esym.asym.sc == scSCommon)
2822         h->esym.asym.sc = scSBss;
2823
2824       sec = h->root.root.u.def.section;
2825       output_section = sec->output_section;
2826       if (output_section != NULL)
2827         h->esym.asym.value = (h->root.root.u.def.value
2828                               + sec->output_offset
2829                               + output_section->vma);
2830       else
2831         h->esym.asym.value = 0;
2832     }
2833   else if (h->root.needs_plt)
2834     {
2835       /* Set type and value for a symbol with a function stub.  */
2836       h->esym.asym.st = stProc;
2837       sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2838       if (sec == NULL)
2839         h->esym.asym.value = 0;
2840       else
2841         {
2842           output_section = sec->output_section;
2843           if (output_section != NULL)
2844             h->esym.asym.value = (h->root.plt.offset
2845                                   + sec->output_offset
2846                                   + output_section->vma);
2847           else
2848             h->esym.asym.value = 0;
2849         }
2850     }
2851
2852   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2853                                       h->root.root.root.string,
2854                                       &h->esym))
2855     {
2856       einfo->failed = TRUE;
2857       return FALSE;
2858     }
2859
2860   return TRUE;
2861 }
2862 \f
2863 /* Search for and possibly create a got entry.  */
2864
2865 static struct alpha_elf_got_entry *
2866 get_got_entry (abfd, h, r_type, r_symndx, r_addend)
2867      bfd *abfd;
2868      struct alpha_elf_link_hash_entry *h;
2869      unsigned long r_type, r_symndx;
2870      bfd_vma r_addend;
2871 {
2872   struct alpha_elf_got_entry *gotent;
2873   struct alpha_elf_got_entry **slot;
2874
2875   if (h)
2876     slot = &h->got_entries;
2877   else
2878     {
2879       /* This is a local .got entry -- record for merge.  */
2880
2881       struct alpha_elf_got_entry **local_got_entries;
2882
2883       local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2884       if (!local_got_entries)
2885         {
2886           bfd_size_type size;
2887           Elf_Internal_Shdr *symtab_hdr;
2888
2889           symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2890           size = symtab_hdr->sh_info;
2891           size *= sizeof (struct alpha_elf_got_entry *);
2892
2893           local_got_entries
2894             = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
2895           if (!local_got_entries)
2896             return NULL;
2897
2898           alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
2899         }
2900
2901       slot = &local_got_entries[r_symndx];
2902     }
2903
2904   for (gotent = *slot; gotent ; gotent = gotent->next)
2905     if (gotent->gotobj == abfd
2906         && gotent->reloc_type == r_type
2907         && gotent->addend == r_addend)
2908       break;
2909
2910   if (!gotent)
2911     {
2912       int entry_size;
2913       bfd_size_type amt;
2914
2915       amt = sizeof (struct alpha_elf_got_entry);
2916       gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
2917       if (!gotent)
2918         return NULL;
2919
2920       gotent->gotobj = abfd;
2921       gotent->addend = r_addend;
2922       gotent->got_offset = -1;
2923       gotent->use_count = 1;
2924       gotent->reloc_type = r_type;
2925       gotent->reloc_done = 0;
2926       gotent->reloc_xlated = 0;
2927
2928       gotent->next = *slot;
2929       *slot = gotent;
2930
2931       entry_size = alpha_got_entry_size (r_type);
2932       alpha_elf_tdata (abfd)->total_got_size += entry_size;
2933       if (!h)
2934         alpha_elf_tdata(abfd)->local_got_size += entry_size;
2935     }
2936   else
2937     gotent->use_count += 1;
2938
2939   return gotent;
2940 }
2941
2942 /* Handle dynamic relocations when doing an Alpha ELF link.  */
2943
2944 static bfd_boolean
2945 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2946      bfd *abfd;
2947      struct bfd_link_info *info;
2948      asection *sec;
2949      const Elf_Internal_Rela *relocs;
2950 {
2951   bfd *dynobj;
2952   asection *sreloc;
2953   const char *rel_sec_name;
2954   Elf_Internal_Shdr *symtab_hdr;
2955   struct alpha_elf_link_hash_entry **sym_hashes;
2956   const Elf_Internal_Rela *rel, *relend;
2957   bfd_boolean got_created;
2958   bfd_size_type amt;
2959
2960   if (info->relocatable)
2961     return TRUE;
2962
2963   dynobj = elf_hash_table(info)->dynobj;
2964   if (dynobj == NULL)
2965     elf_hash_table(info)->dynobj = dynobj = abfd;
2966
2967   sreloc = NULL;
2968   rel_sec_name = NULL;
2969   symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2970   sym_hashes = alpha_elf_sym_hashes(abfd);
2971   got_created = FALSE;
2972
2973   relend = relocs + sec->reloc_count;
2974   for (rel = relocs; rel < relend; ++rel)
2975     {
2976       enum {
2977         NEED_GOT = 1,
2978         NEED_GOT_ENTRY = 2,
2979         NEED_DYNREL = 4
2980       };
2981
2982       unsigned long r_symndx, r_type;
2983       struct alpha_elf_link_hash_entry *h;
2984       unsigned int gotent_flags;
2985       bfd_boolean maybe_dynamic;
2986       unsigned int need;
2987       bfd_vma addend;
2988
2989       r_symndx = ELF64_R_SYM (rel->r_info);
2990       if (r_symndx < symtab_hdr->sh_info)
2991         h = NULL;
2992       else
2993         {
2994           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2995
2996           while (h->root.root.type == bfd_link_hash_indirect
2997                  || h->root.root.type == bfd_link_hash_warning)
2998             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2999
3000           h->root.ref_regular = 1;
3001         }
3002
3003       /* We can only get preliminary data on whether a symbol is
3004          locally or externally defined, as not all of the input files
3005          have yet been processed.  Do something with what we know, as
3006          this may help reduce memory usage and processing time later.  */
3007       maybe_dynamic = FALSE;
3008       if (h && ((info->shared
3009                  && (!info->symbolic || info->unresolved_syms_in_shared_libs == RM_IGNORE))
3010                 || !h->root.def_regular
3011                 || h->root.root.type == bfd_link_hash_defweak))
3012         maybe_dynamic = TRUE;
3013
3014       need = 0;
3015       gotent_flags = 0;
3016       r_type = ELF64_R_TYPE (rel->r_info);
3017       addend = rel->r_addend;
3018
3019       switch (r_type)
3020         {
3021         case R_ALPHA_LITERAL:
3022           need = NEED_GOT | NEED_GOT_ENTRY;
3023
3024           /* Remember how this literal is used from its LITUSEs.
3025              This will be important when it comes to decide if we can
3026              create a .plt entry for a function symbol.  */
3027           while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
3028             if (rel->r_addend >= 1 && rel->r_addend <= 5)
3029               gotent_flags |= 1 << rel->r_addend;
3030           --rel;
3031
3032           /* No LITUSEs -- presumably the address is used somehow.  */
3033           if (gotent_flags == 0)
3034             gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
3035           break;
3036
3037         case R_ALPHA_GPDISP:
3038         case R_ALPHA_GPREL16:
3039         case R_ALPHA_GPREL32:
3040         case R_ALPHA_GPRELHIGH:
3041         case R_ALPHA_GPRELLOW:
3042         case R_ALPHA_BRSGP:
3043           need = NEED_GOT;
3044           break;
3045
3046         case R_ALPHA_REFLONG:
3047         case R_ALPHA_REFQUAD:
3048           if ((info->shared && (sec->flags & SEC_ALLOC)) || maybe_dynamic)
3049             need = NEED_DYNREL;
3050           break;
3051
3052         case R_ALPHA_TLSLDM:
3053           /* The symbol for a TLSLDM reloc is ignored.  Collapse the
3054              reloc to the 0 symbol so that they all match.  */
3055           r_symndx = 0;
3056           h = 0;
3057           maybe_dynamic = FALSE;
3058           /* FALLTHRU */
3059
3060         case R_ALPHA_TLSGD:
3061         case R_ALPHA_GOTDTPREL:
3062           need = NEED_GOT | NEED_GOT_ENTRY;
3063           break;
3064
3065         case R_ALPHA_GOTTPREL:
3066           need = NEED_GOT | NEED_GOT_ENTRY;
3067           gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
3068           if (info->shared)
3069             info->flags |= DF_STATIC_TLS;
3070           break;
3071
3072         case R_ALPHA_TPREL64:
3073           if (info->shared || maybe_dynamic)
3074             need = NEED_DYNREL;
3075           if (info->shared)
3076             info->flags |= DF_STATIC_TLS;
3077           break;
3078         }
3079
3080       if (need & NEED_GOT)
3081         {
3082           if (!got_created)
3083             {
3084               if (!elf64_alpha_create_got_section (abfd, info))
3085                 return FALSE;
3086
3087               /* Make sure the object's gotobj is set to itself so
3088                  that we default to every object with its own .got.
3089                  We'll merge .gots later once we've collected each
3090                  object's info.  */
3091               alpha_elf_tdata(abfd)->gotobj = abfd;
3092
3093               got_created = 1;
3094             }
3095         }
3096
3097       if (need & NEED_GOT_ENTRY)
3098         {
3099           struct alpha_elf_got_entry *gotent;
3100
3101           gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
3102           if (!gotent)
3103             return FALSE;
3104
3105           if (gotent_flags)
3106             {
3107               gotent->flags |= gotent_flags;
3108               if (h)
3109                 {
3110                   gotent_flags |= h->flags;
3111                   h->flags = gotent_flags;
3112
3113                   /* Make a guess as to whether a .plt entry is needed.  */
3114                   if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3115                       && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))
3116                     h->root.needs_plt = 1;
3117                   else
3118                     h->root.needs_plt = 0;
3119                 }
3120             }
3121         }
3122
3123       if (need & NEED_DYNREL)
3124         {
3125           if (rel_sec_name == NULL)
3126             {
3127               rel_sec_name = (bfd_elf_string_from_elf_section
3128                               (abfd, elf_elfheader(abfd)->e_shstrndx,
3129                                elf_section_data(sec)->rel_hdr.sh_name));
3130               if (rel_sec_name == NULL)
3131                 return FALSE;
3132
3133               BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
3134                           && strcmp (bfd_get_section_name (abfd, sec),
3135                                      rel_sec_name+5) == 0);
3136             }
3137
3138           /* We need to create the section here now whether we eventually
3139              use it or not so that it gets mapped to an output section by
3140              the linker.  If not used, we'll kill it in
3141              size_dynamic_sections.  */
3142           if (sreloc == NULL)
3143             {
3144               sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
3145               if (sreloc == NULL)
3146                 {
3147                   flagword flags;
3148
3149                   sreloc = bfd_make_section (dynobj, rel_sec_name);
3150                   flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
3151                            | SEC_LINKER_CREATED | SEC_READONLY);
3152                   if (sec->flags & SEC_ALLOC)
3153                     flags |= SEC_ALLOC | SEC_LOAD;
3154                   if (sreloc == NULL
3155                       || !bfd_set_section_flags (dynobj, sreloc, flags)
3156                       || !bfd_set_section_alignment (dynobj, sreloc, 3))
3157                     return FALSE;
3158                 }
3159             }
3160
3161           if (h)
3162             {
3163               /* Since we havn't seen all of the input symbols yet, we
3164                  don't know whether we'll actually need a dynamic relocation
3165                  entry for this reloc.  So make a record of it.  Once we
3166                  find out if this thing needs dynamic relocation we'll
3167                  expand the relocation sections by the appropriate amount.  */
3168
3169               struct alpha_elf_reloc_entry *rent;
3170
3171               for (rent = h->reloc_entries; rent; rent = rent->next)
3172                 if (rent->rtype == r_type && rent->srel == sreloc)
3173                   break;
3174
3175               if (!rent)
3176                 {
3177                   amt = sizeof (struct alpha_elf_reloc_entry);
3178                   rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
3179                   if (!rent)
3180                     return FALSE;
3181
3182                   rent->srel = sreloc;
3183                   rent->rtype = r_type;
3184                   rent->count = 1;
3185                   rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3186                                    == (SEC_READONLY | SEC_ALLOC));
3187
3188                   rent->next = h->reloc_entries;
3189                   h->reloc_entries = rent;
3190                 }
3191               else
3192                 rent->count++;
3193             }
3194           else if (info->shared)
3195             {
3196               /* If this is a shared library, and the section is to be
3197                  loaded into memory, we need a RELATIVE reloc.  */
3198               sreloc->size += sizeof (Elf64_External_Rela);
3199               if ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3200                   == (SEC_READONLY | SEC_ALLOC))
3201                 info->flags |= DF_TEXTREL;
3202             }
3203         }
3204     }
3205
3206   return TRUE;
3207 }
3208
3209 /* Adjust a symbol defined by a dynamic object and referenced by a
3210    regular object.  The current definition is in some section of the
3211    dynamic object, but we're not including those sections.  We have to
3212    change the definition to something the rest of the link can
3213    understand.  */
3214
3215 static bfd_boolean
3216 elf64_alpha_adjust_dynamic_symbol (info, h)
3217      struct bfd_link_info *info;
3218      struct elf_link_hash_entry *h;
3219 {
3220   bfd *dynobj;
3221   asection *s;
3222   struct alpha_elf_link_hash_entry *ah;
3223
3224   dynobj = elf_hash_table(info)->dynobj;
3225   ah = (struct alpha_elf_link_hash_entry *)h;
3226
3227   /* Now that we've seen all of the input symbols, finalize our decision
3228      about whether this symbol should get a .plt entry.  */
3229
3230   if (alpha_elf_dynamic_symbol_p (h, info)
3231       && ((h->type == STT_FUNC
3232            && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
3233           || (h->type == STT_NOTYPE
3234               && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3235               && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)))
3236       /* Don't prevent otherwise valid programs from linking by attempting
3237          to create a new .got entry somewhere.  A Correct Solution would be
3238          to add a new .got section to a new object file and let it be merged
3239          somewhere later.  But for now don't bother.  */
3240       && ah->got_entries)
3241     {
3242       h->needs_plt = 1;
3243
3244       s = bfd_get_section_by_name(dynobj, ".plt");
3245       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
3246         return FALSE;
3247
3248       /* The first bit of the .plt is reserved.  */
3249       if (s->size == 0)
3250         s->size = PLT_HEADER_SIZE;
3251
3252       h->plt.offset = s->size;
3253       s->size += PLT_ENTRY_SIZE;
3254
3255       /* If this symbol is not defined in a regular file, and we are not
3256          generating a shared library, then set the symbol to the location
3257          in the .plt.  This is required to make function pointers compare
3258          equal between the normal executable and the shared library.  */
3259       if (! info->shared
3260           && h->root.type != bfd_link_hash_defweak)
3261         {
3262           ah->plt_old_section = h->root.u.def.section;
3263           ah->plt_old_value = h->root.u.def.value;
3264           ah->flags |= ALPHA_ELF_LINK_HASH_PLT_LOC;
3265           h->root.u.def.section = s;
3266           h->root.u.def.value = h->plt.offset;
3267         }
3268
3269       /* We also need a JMP_SLOT entry in the .rela.plt section.  */
3270       s = bfd_get_section_by_name (dynobj, ".rela.plt");
3271       BFD_ASSERT (s != NULL);
3272       s->size += sizeof (Elf64_External_Rela);
3273
3274       return TRUE;
3275     }
3276   else
3277     h->needs_plt = 0;
3278
3279   /* If this is a weak symbol, and there is a real definition, the
3280      processor independent code will have arranged for us to see the
3281      real definition first, and we can just use the same value.  */
3282   if (h->u.weakdef != NULL)
3283     {
3284       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3285                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3286       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3287       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3288       return TRUE;
3289     }
3290
3291   /* This is a reference to a symbol defined by a dynamic object which
3292      is not a function.  The Alpha, since it uses .got entries for all
3293      symbols even in regular objects, does not need the hackery of a
3294      .dynbss section and COPY dynamic relocations.  */
3295
3296   return TRUE;
3297 }
3298
3299 /* Symbol versioning can create new symbols, and make our old symbols
3300    indirect to the new ones.  Consolidate the got and reloc information
3301    in these situations.  */
3302
3303 static bfd_boolean
3304 elf64_alpha_merge_ind_symbols (hi, dummy)
3305      struct alpha_elf_link_hash_entry *hi;
3306      PTR dummy ATTRIBUTE_UNUSED;
3307 {
3308   struct alpha_elf_link_hash_entry *hs;
3309
3310   if (hi->root.root.type != bfd_link_hash_indirect)
3311     return TRUE;
3312   hs = hi;
3313   do {
3314     hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
3315   } while (hs->root.root.type == bfd_link_hash_indirect);
3316
3317   /* Merge the flags.  Whee.  */
3318
3319   hs->flags |= hi->flags;
3320
3321   /* Merge the .got entries.  Cannibalize the old symbol's list in
3322      doing so, since we don't need it anymore.  */
3323
3324   if (hs->got_entries == NULL)
3325     hs->got_entries = hi->got_entries;
3326   else
3327     {
3328       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
3329
3330       gsh = hs->got_entries;
3331       for (gi = hi->got_entries; gi ; gi = gin)
3332         {
3333           gin = gi->next;
3334           for (gs = gsh; gs ; gs = gs->next)
3335             if (gi->gotobj == gs->gotobj
3336                 && gi->reloc_type == gs->reloc_type
3337                 && gi->addend == gs->addend)
3338               {
3339                 gi->use_count += gs->use_count;
3340                 goto got_found;
3341               }
3342           gi->next = hs->got_entries;
3343           hs->got_entries = gi;
3344         got_found:;
3345         }
3346     }
3347   hi->got_entries = NULL;
3348
3349   /* And similar for the reloc entries.  */
3350
3351   if (hs->reloc_entries == NULL)
3352     hs->reloc_entries = hi->reloc_entries;
3353   else
3354     {
3355       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
3356
3357       rsh = hs->reloc_entries;
3358       for (ri = hi->reloc_entries; ri ; ri = rin)
3359         {
3360           rin = ri->next;
3361           for (rs = rsh; rs ; rs = rs->next)
3362             if (ri->rtype == rs->rtype && ri->srel == rs->srel)
3363               {
3364                 rs->count += ri->count;
3365                 goto found_reloc;
3366               }
3367           ri->next = hs->reloc_entries;
3368           hs->reloc_entries = ri;
3369         found_reloc:;
3370         }
3371     }
3372   hi->reloc_entries = NULL;
3373
3374   return TRUE;
3375 }
3376
3377 /* Is it possible to merge two object file's .got tables?  */
3378
3379 static bfd_boolean
3380 elf64_alpha_can_merge_gots (a, b)
3381      bfd *a, *b;
3382 {
3383   int total = alpha_elf_tdata (a)->total_got_size;
3384   bfd *bsub;
3385
3386   /* Trivial quick fallout test.  */
3387   if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
3388     return TRUE;
3389
3390   /* By their nature, local .got entries cannot be merged.  */
3391   if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
3392     return FALSE;
3393
3394   /* Failing the common trivial comparison, we must effectively
3395      perform the merge.  Not actually performing the merge means that
3396      we don't have to store undo information in case we fail.  */
3397   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3398     {
3399       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
3400       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3401       int i, n;
3402
3403       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3404       for (i = 0; i < n; ++i)
3405         {
3406           struct alpha_elf_got_entry *ae, *be;
3407           struct alpha_elf_link_hash_entry *h;
3408
3409           h = hashes[i];
3410           while (h->root.root.type == bfd_link_hash_indirect
3411                  || h->root.root.type == bfd_link_hash_warning)
3412             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3413
3414           for (be = h->got_entries; be ; be = be->next)
3415             {
3416               if (be->use_count == 0)
3417                 continue;
3418               if (be->gotobj != b)
3419                 continue;
3420
3421               for (ae = h->got_entries; ae ; ae = ae->next)
3422                 if (ae->gotobj == a
3423                     && ae->reloc_type == be->reloc_type
3424                     && ae->addend == be->addend)
3425                   goto global_found;
3426
3427               total += alpha_got_entry_size (be->reloc_type);
3428               if (total > MAX_GOT_SIZE)
3429                 return FALSE;
3430             global_found:;
3431             }
3432         }
3433     }
3434
3435   return TRUE;
3436 }
3437
3438 /* Actually merge two .got tables.  */
3439
3440 static void
3441 elf64_alpha_merge_gots (a, b)
3442      bfd *a, *b;
3443 {
3444   int total = alpha_elf_tdata (a)->total_got_size;
3445   bfd *bsub;
3446
3447   /* Remember local expansion.  */
3448   {
3449     int e = alpha_elf_tdata (b)->local_got_size;
3450     total += e;
3451     alpha_elf_tdata (a)->local_got_size += e;
3452   }
3453
3454   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3455     {
3456       struct alpha_elf_got_entry **local_got_entries;
3457       struct alpha_elf_link_hash_entry **hashes;
3458       Elf_Internal_Shdr *symtab_hdr;
3459       int i, n;
3460
3461       /* Let the local .got entries know they are part of a new subsegment.  */
3462       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
3463       if (local_got_entries)
3464         {
3465           n = elf_tdata (bsub)->symtab_hdr.sh_info;
3466           for (i = 0; i < n; ++i)
3467             {
3468               struct alpha_elf_got_entry *ent;
3469               for (ent = local_got_entries[i]; ent; ent = ent->next)
3470                 ent->gotobj = a;
3471             }
3472         }
3473
3474       /* Merge the global .got entries.  */
3475       hashes = alpha_elf_sym_hashes (bsub);
3476       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3477
3478       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3479       for (i = 0; i < n; ++i)
3480         {
3481           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
3482           struct alpha_elf_link_hash_entry *h;
3483
3484           h = hashes[i];
3485           while (h->root.root.type == bfd_link_hash_indirect
3486                  || h->root.root.type == bfd_link_hash_warning)
3487             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3488
3489           start = &h->got_entries;
3490           for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
3491             {
3492               if (be->use_count == 0)
3493                 {
3494                   *pbe = be->next;
3495                   continue;
3496                 }
3497               if (be->gotobj != b)
3498                 continue;
3499
3500               for (ae = *start; ae ; ae = ae->next)
3501                 if (ae->gotobj == a
3502                     && ae->reloc_type == be->reloc_type
3503                     && ae->addend == be->addend)
3504                   {
3505                     ae->flags |= be->flags;
3506                     ae->use_count += be->use_count;
3507                     *pbe = be->next;
3508                     goto global_found;
3509                   }
3510               be->gotobj = a;
3511               total += alpha_got_entry_size (be->reloc_type);
3512
3513             global_found:;
3514             }
3515         }
3516
3517       alpha_elf_tdata (bsub)->gotobj = a;
3518     }
3519   alpha_elf_tdata (a)->total_got_size = total;
3520
3521   /* Merge the two in_got chains.  */
3522   {
3523     bfd *next;
3524
3525     bsub = a;
3526     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
3527       bsub = next;
3528
3529     alpha_elf_tdata (bsub)->in_got_link_next = b;
3530   }
3531 }
3532
3533 /* Calculate the offsets for the got entries.  */
3534
3535 static bfd_boolean
3536 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
3537      struct alpha_elf_link_hash_entry *h;
3538      PTR arg ATTRIBUTE_UNUSED;
3539 {
3540   bfd_boolean result = TRUE;
3541   struct alpha_elf_got_entry *gotent;
3542
3543   if (h->root.root.type == bfd_link_hash_warning)
3544     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3545
3546   for (gotent = h->got_entries; gotent; gotent = gotent->next)
3547     if (gotent->use_count > 0)
3548       {
3549         struct alpha_elf_obj_tdata *td;
3550         bfd_size_type *plge;
3551
3552         td = alpha_elf_tdata (gotent->gotobj);
3553         if (td == NULL)
3554           {
3555             _bfd_error_handler (_("Symbol %s has no GOT subsection for offset 0x%x"),
3556                                 h->root.root.root.string, gotent->got_offset);
3557             result = FALSE;
3558             continue;
3559           }
3560         plge = &td->got->size;
3561         gotent->got_offset = *plge;
3562         *plge += alpha_got_entry_size (gotent->reloc_type);
3563       }
3564
3565   return result;
3566 }
3567
3568 static void
3569 elf64_alpha_calc_got_offsets (info)
3570      struct bfd_link_info *info;
3571 {
3572   bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
3573
3574   /* First, zero out the .got sizes, as we may be recalculating the
3575      .got after optimizing it.  */
3576   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3577     alpha_elf_tdata(i)->got->size = 0;
3578
3579   /* Next, fill in the offsets for all the global entries.  */
3580   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3581                                 elf64_alpha_calc_got_offsets_for_symbol,
3582                                 NULL);
3583
3584   /* Finally, fill in the offsets for the local entries.  */
3585   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3586     {
3587       bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
3588       bfd *j;
3589
3590       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3591         {
3592           struct alpha_elf_got_entry **local_got_entries, *gotent;
3593           int k, n;
3594
3595           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3596           if (!local_got_entries)
3597             continue;
3598
3599           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3600             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3601               if (gotent->use_count > 0)
3602                 {
3603                   gotent->got_offset = got_offset;
3604                   got_offset += alpha_got_entry_size (gotent->reloc_type);
3605                 }
3606         }
3607
3608       alpha_elf_tdata(i)->got->size = got_offset;
3609     }
3610 }
3611
3612 /* Constructs the gots.  */
3613
3614 static bfd_boolean
3615 elf64_alpha_size_got_sections (info)
3616      struct bfd_link_info *info;
3617 {
3618   bfd *i, *got_list, *cur_got_obj = NULL;
3619   int something_changed = 0;
3620
3621   got_list = alpha_elf_hash_table (info)->got_list;
3622
3623   /* On the first time through, pretend we have an existing got list
3624      consisting of all of the input files.  */
3625   if (got_list == NULL)
3626     {
3627       for (i = info->input_bfds; i ; i = i->link_next)
3628         {
3629           bfd *this_got = alpha_elf_tdata (i)->gotobj;
3630           if (this_got == NULL)
3631             continue;
3632
3633           /* We are assuming no merging has yet occurred.  */
3634           BFD_ASSERT (this_got == i);
3635
3636           if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
3637             {
3638               /* Yikes! A single object file has too many entries.  */
3639               (*_bfd_error_handler)
3640                 (_("%B: .got subsegment exceeds 64K (size %d)"),
3641                  i, alpha_elf_tdata (this_got)->total_got_size);
3642               return FALSE;
3643             }
3644
3645           if (got_list == NULL)
3646             got_list = this_got;
3647           else
3648             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3649           cur_got_obj = this_got;
3650         }
3651
3652       /* Strange degenerate case of no got references.  */
3653       if (got_list == NULL)
3654         return TRUE;
3655
3656       alpha_elf_hash_table (info)->got_list = got_list;
3657
3658       /* Force got offsets to be recalculated.  */
3659       something_changed = 1;
3660     }
3661
3662   cur_got_obj = got_list;
3663   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3664   while (i != NULL)
3665     {
3666       if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3667         {
3668           elf64_alpha_merge_gots (cur_got_obj, i);
3669           i = alpha_elf_tdata(i)->got_link_next;
3670           alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3671           something_changed = 1;
3672         }
3673       else
3674         {
3675           cur_got_obj = i;
3676           i = alpha_elf_tdata(i)->got_link_next;
3677         }
3678     }
3679
3680   /* Once the gots have been merged, fill in the got offsets for
3681      everything therein.  */
3682   if (1 || something_changed)
3683     elf64_alpha_calc_got_offsets (info);
3684
3685   return TRUE;
3686 }
3687
3688 /* Called from relax_section to rebuild the PLT in light of
3689    potential changes in the function's status.  */
3690
3691 static bfd_boolean
3692 elf64_alpha_size_plt_section (info)
3693      struct bfd_link_info *info;
3694 {
3695   asection *splt, *spltrel;
3696   unsigned long entries;
3697   bfd *dynobj;
3698
3699   dynobj = elf_hash_table(info)->dynobj;
3700   splt = bfd_get_section_by_name(dynobj, ".plt");
3701   if (splt == NULL)
3702     return TRUE;
3703
3704   splt->size = 0;
3705
3706   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3707                                 elf64_alpha_size_plt_section_1, splt);
3708
3709   /* Every plt entry requires a JMP_SLOT relocation.  */
3710   spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
3711   if (splt->size)
3712     entries = (splt->size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3713   else
3714     entries = 0;
3715   spltrel->size = entries * sizeof (Elf64_External_Rela);
3716
3717   return TRUE;
3718 }
3719
3720 static bfd_boolean
3721 elf64_alpha_size_plt_section_1 (h, data)
3722      struct alpha_elf_link_hash_entry *h;
3723      PTR data;
3724 {
3725   asection *splt = (asection *) data;
3726   struct alpha_elf_got_entry *gotent;
3727
3728   /* If we didn't need an entry before, we still don't.  */
3729   if (!h->root.needs_plt)
3730     return TRUE;
3731
3732   /* There must still be a LITERAL got entry for the function.  */
3733   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3734     if (gotent->reloc_type == R_ALPHA_LITERAL
3735         && gotent->use_count > 0)
3736       break;
3737
3738   /* If there is, reset the PLT offset.  If not, there's no longer
3739      a need for the PLT entry.  */
3740   if (gotent)
3741     {
3742       if (splt->size == 0)
3743         splt->size = PLT_HEADER_SIZE;
3744       h->root.plt.offset = splt->size;
3745       splt->size += PLT_ENTRY_SIZE;
3746     }
3747   else
3748     {
3749       h->root.needs_plt = 0;
3750       h->root.plt.offset = -1;
3751
3752       /* Undo the definition frobbing begun in adjust_dynamic_symbol.  */
3753       if (h->flags & ALPHA_ELF_LINK_HASH_PLT_LOC)
3754         {
3755           h->root.root.u.def.section = h->plt_old_section;
3756           h->root.root.u.def.value = h->plt_old_value;
3757           h->flags &= ~ALPHA_ELF_LINK_HASH_PLT_LOC;
3758         }
3759     }
3760
3761   return TRUE;
3762 }
3763
3764 static bfd_boolean
3765 elf64_alpha_always_size_sections (output_bfd, info)
3766      bfd *output_bfd ATTRIBUTE_UNUSED;
3767      struct bfd_link_info *info;
3768 {
3769   bfd *i;
3770
3771   if (info->relocatable)
3772     return TRUE;
3773
3774   /* First, take care of the indirect symbols created by versioning.  */
3775   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3776                                 elf64_alpha_merge_ind_symbols,
3777                                 NULL);
3778
3779   if (!elf64_alpha_size_got_sections (info))
3780     return FALSE;
3781
3782   /* Allocate space for all of the .got subsections.  */
3783   i = alpha_elf_hash_table (info)->got_list;
3784   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3785     {
3786       asection *s = alpha_elf_tdata(i)->got;
3787       if (s->size > 0)
3788         {
3789           s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
3790           if (s->contents == NULL)
3791             return FALSE;
3792         }
3793     }
3794
3795   return TRUE;
3796 }
3797
3798 /* The number of dynamic relocations required by a static relocation.  */
3799
3800 static int
3801 alpha_dynamic_entries_for_reloc (r_type, dynamic, shared)
3802      int r_type, dynamic, shared;
3803 {
3804   switch (r_type)
3805     {
3806     /* May appear in GOT entries.  */
3807     case R_ALPHA_TLSGD:
3808       return (dynamic ? 2 : shared ? 1 : 0);
3809     case R_ALPHA_TLSLDM:
3810       return shared;
3811     case R_ALPHA_LITERAL:
3812     case R_ALPHA_GOTTPREL:
3813       return dynamic || shared;
3814     case R_ALPHA_GOTDTPREL:
3815       return dynamic;
3816
3817     /* May appear in data sections.  */
3818     case R_ALPHA_REFLONG:
3819     case R_ALPHA_REFQUAD:
3820     case R_ALPHA_TPREL64:
3821       return dynamic || shared;
3822
3823     /* Everything else is illegal.  We'll issue an error during
3824        relocate_section.  */
3825     default:
3826       return 0;
3827     }
3828 }
3829
3830 /* Work out the sizes of the dynamic relocation entries.  */
3831
3832 static bfd_boolean
3833 elf64_alpha_calc_dynrel_sizes (h, info)
3834      struct alpha_elf_link_hash_entry *h;
3835      struct bfd_link_info *info;
3836 {
3837   bfd_boolean dynamic;
3838   struct alpha_elf_reloc_entry *relent;
3839   unsigned long entries;
3840
3841   if (h->root.root.type == bfd_link_hash_warning)
3842     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3843
3844   /* If the symbol was defined as a common symbol in a regular object
3845      file, and there was no definition in any dynamic object, then the
3846      linker will have allocated space for the symbol in a common
3847      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3848      set.  This is done for dynamic symbols in
3849      elf_adjust_dynamic_symbol but this is not done for non-dynamic
3850      symbols, somehow.  */
3851   if (!h->root.def_regular
3852       && h->root.ref_regular
3853       && !h->root.def_dynamic
3854       && (h->root.root.type == bfd_link_hash_defined
3855           || h->root.root.type == bfd_link_hash_defweak)
3856       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3857     h->root.def_regular = 1;
3858
3859   /* If the symbol is dynamic, we'll need all the relocations in their
3860      natural form.  If this is a shared object, and it has been forced
3861      local, we'll need the same number of RELATIVE relocations.  */
3862
3863   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
3864
3865   for (relent = h->reloc_entries; relent; relent = relent->next)
3866     {
3867       entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
3868                                                  info->shared);
3869       if (entries)
3870         {
3871           relent->srel->size +=
3872             entries * sizeof (Elf64_External_Rela) * relent->count;
3873           if (relent->reltext)
3874             info->flags |= DT_TEXTREL;
3875         }
3876     }
3877
3878   return TRUE;
3879 }
3880
3881 /* Set the sizes of the dynamic relocation sections.  */
3882
3883 static bfd_boolean
3884 elf64_alpha_size_rela_got_section (info)
3885      struct bfd_link_info *info;
3886 {
3887   unsigned long entries;
3888   bfd *i, *dynobj;
3889   asection *srel;
3890
3891   /* Shared libraries often require RELATIVE relocs, and some relocs
3892      require attention for the main application as well.  */
3893
3894   entries = 0;
3895   for (i = alpha_elf_hash_table(info)->got_list;
3896        i ; i = alpha_elf_tdata(i)->got_link_next)
3897     {
3898       bfd *j;
3899
3900       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3901         {
3902           struct alpha_elf_got_entry **local_got_entries, *gotent;
3903           int k, n;
3904
3905           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3906           if (!local_got_entries)
3907             continue;
3908
3909           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3910             for (gotent = local_got_entries[k];
3911                  gotent ; gotent = gotent->next)
3912               if (gotent->use_count > 0)
3913                 entries += (alpha_dynamic_entries_for_reloc
3914                             (gotent->reloc_type, 0, info->shared));
3915         }
3916     }
3917
3918   dynobj = elf_hash_table(info)->dynobj;
3919   srel = bfd_get_section_by_name (dynobj, ".rela.got");
3920   if (!srel)
3921     {
3922       BFD_ASSERT (entries == 0);
3923       return TRUE;
3924     }
3925   srel->size = sizeof (Elf64_External_Rela) * entries;
3926
3927   /* Now do the non-local symbols.  */
3928   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3929                                 elf64_alpha_size_rela_got_1, info);
3930
3931   return TRUE;
3932 }
3933
3934 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
3935    global symbols.  */
3936
3937 static bfd_boolean
3938 elf64_alpha_size_rela_got_1 (h, info)
3939      struct alpha_elf_link_hash_entry *h;
3940      struct bfd_link_info *info;
3941 {
3942   bfd_boolean dynamic;
3943   struct alpha_elf_got_entry *gotent;
3944   unsigned long entries;
3945
3946   if (h->root.root.type == bfd_link_hash_warning)
3947     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3948
3949   /* If the symbol is dynamic, we'll need all the relocations in their
3950      natural form.  If this is a shared object, and it has been forced
3951      local, we'll need the same number of RELATIVE relocations.  */
3952
3953   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
3954
3955   entries = 0;
3956   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3957     if (gotent->use_count > 0)
3958       entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type,
3959                                                   dynamic, info->shared);
3960
3961   /* If we are using a .plt entry, subtract one, as the first
3962      reference uses a .rela.plt entry instead.  */
3963   if (h->root.plt.offset != MINUS_ONE)
3964     entries--;
3965
3966   if (entries > 0)
3967     {
3968       bfd *dynobj = elf_hash_table(info)->dynobj;
3969       asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
3970       BFD_ASSERT (srel != NULL);
3971       srel->size += sizeof (Elf64_External_Rela) * entries;
3972     }
3973
3974   return TRUE;
3975 }
3976
3977 /* Set the sizes of the dynamic sections.  */
3978
3979 static bfd_boolean
3980 elf64_alpha_size_dynamic_sections (output_bfd, info)
3981      bfd *output_bfd ATTRIBUTE_UNUSED;
3982      struct bfd_link_info *info;
3983 {
3984   bfd *dynobj;
3985   asection *s;
3986   bfd_boolean relplt;
3987
3988   dynobj = elf_hash_table(info)->dynobj;
3989   BFD_ASSERT(dynobj != NULL);
3990
3991   if (elf_hash_table (info)->dynamic_sections_created)
3992     {
3993       /* Set the contents of the .interp section to the interpreter.  */
3994       if (info->executable)
3995         {
3996           s = bfd_get_section_by_name (dynobj, ".interp");
3997           BFD_ASSERT (s != NULL);
3998           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3999           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4000         }
4001
4002       /* Now that we've seen all of the input files, we can decide which
4003          symbols need dynamic relocation entries and which don't.  We've
4004          collected information in check_relocs that we can now apply to
4005          size the dynamic relocation sections.  */
4006       alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
4007                                     elf64_alpha_calc_dynrel_sizes, info);
4008
4009       elf64_alpha_size_rela_got_section (info);
4010     }
4011   /* else we're not dynamic and by definition we don't need such things.  */
4012
4013   /* The check_relocs and adjust_dynamic_symbol entry points have
4014      determined the sizes of the various dynamic sections.  Allocate
4015      memory for them.  */
4016   relplt = FALSE;
4017   for (s = dynobj->sections; s != NULL; s = s->next)
4018     {
4019       const char *name;
4020       bfd_boolean strip;
4021
4022       if (!(s->flags & SEC_LINKER_CREATED))
4023         continue;
4024
4025       /* It's OK to base decisions on the section name, because none
4026          of the dynobj section names depend upon the input files.  */
4027       name = bfd_get_section_name (dynobj, s);
4028
4029       /* If we don't need this section, strip it from the output file.
4030          This is to handle .rela.bss and .rela.plt.  We must create it
4031          in create_dynamic_sections, because it must be created before
4032          the linker maps input sections to output sections.  The
4033          linker does that before adjust_dynamic_symbol is called, and
4034          it is that function which decides whether anything needs to
4035          go into these sections.  */
4036
4037       strip = FALSE;
4038
4039       if (strncmp (name, ".rela", 5) == 0)
4040         {
4041           strip = (s->size == 0);
4042
4043           if (!strip)
4044             {
4045               if (strcmp(name, ".rela.plt") == 0)
4046                 relplt = TRUE;
4047
4048               /* We use the reloc_count field as a counter if we need
4049                  to copy relocs into the output file.  */
4050               s->reloc_count = 0;
4051             }
4052         }
4053       else if (strcmp (name, ".plt") != 0)
4054         {
4055           /* It's not one of our dynamic sections, so don't allocate space.  */
4056           continue;
4057         }
4058
4059       if (strip)
4060         _bfd_strip_section_from_output (info, s);
4061       else
4062         {
4063           /* Allocate memory for the section contents.  */
4064           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4065           if (s->contents == NULL && s->size != 0)
4066             return FALSE;
4067         }
4068     }
4069
4070   if (elf_hash_table (info)->dynamic_sections_created)
4071     {
4072       /* Add some entries to the .dynamic section.  We fill in the
4073          values later, in elf64_alpha_finish_dynamic_sections, but we
4074          must add the entries now so that we get the correct size for
4075          the .dynamic section.  The DT_DEBUG entry is filled in by the
4076          dynamic linker and used by the debugger.  */
4077 #define add_dynamic_entry(TAG, VAL) \
4078   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4079
4080       if (info->executable)
4081         {
4082           if (!add_dynamic_entry (DT_DEBUG, 0))
4083             return FALSE;
4084         }
4085
4086       if (relplt)
4087         {
4088           if (!add_dynamic_entry (DT_PLTGOT, 0)
4089               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4090               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4091               || !add_dynamic_entry (DT_JMPREL, 0))
4092             return FALSE;
4093         }
4094
4095       if (!add_dynamic_entry (DT_RELA, 0)
4096           || !add_dynamic_entry (DT_RELASZ, 0)
4097           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
4098         return FALSE;
4099
4100       if (info->flags & DF_TEXTREL)
4101         {
4102           if (!add_dynamic_entry (DT_TEXTREL, 0))
4103             return FALSE;
4104         }
4105     }
4106 #undef add_dynamic_entry
4107
4108   return TRUE;
4109 }
4110
4111 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4112    into the next available slot in SREL.  */
4113
4114 static void
4115 elf64_alpha_emit_dynrel (abfd, info, sec, srel, offset, dynindx, rtype, addend)
4116      bfd *abfd;
4117      struct bfd_link_info *info;
4118      asection *sec, *srel;
4119      bfd_vma offset, addend;
4120      long dynindx, rtype;
4121 {
4122   Elf_Internal_Rela outrel;
4123   bfd_byte *loc;
4124
4125   BFD_ASSERT (srel != NULL);
4126
4127   outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4128   outrel.r_addend = addend;
4129
4130   offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4131   if ((offset | 1) != (bfd_vma) -1)
4132     outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4133   else
4134     memset (&outrel, 0, sizeof (outrel));
4135
4136   loc = srel->contents;
4137   loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4138   bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4139   BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4140 }
4141
4142 /* Relocate an Alpha ELF section for a relocatable link.
4143
4144    We don't have to change anything unless the reloc is against a section
4145    symbol, in which case we have to adjust according to where the section
4146    symbol winds up in the output section.  */
4147
4148 static bfd_boolean
4149 elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section,
4150                                 contents, relocs, local_syms, local_sections)
4151      bfd *output_bfd ATTRIBUTE_UNUSED;
4152      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4153      bfd *input_bfd;
4154      asection *input_section;
4155      bfd_byte *contents ATTRIBUTE_UNUSED;
4156      Elf_Internal_Rela *relocs;
4157      Elf_Internal_Sym *local_syms;
4158      asection **local_sections;
4159 {
4160   unsigned long symtab_hdr_sh_info;
4161   Elf_Internal_Rela *rel;
4162   Elf_Internal_Rela *relend;
4163   bfd_boolean ret_val = TRUE;
4164
4165   symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
4166
4167   relend = relocs + input_section->reloc_count;
4168   for (rel = relocs; rel < relend; rel++)
4169     {
4170       unsigned long r_symndx;
4171       Elf_Internal_Sym *sym;
4172       asection *sec;
4173       unsigned long r_type;
4174
4175       r_type = ELF64_R_TYPE(rel->r_info);
4176       if (r_type >= R_ALPHA_max)
4177         {
4178           (*_bfd_error_handler)
4179             (_("%B: unknown relocation type %d"),
4180              input_bfd, (int) r_type);
4181           bfd_set_error (bfd_error_bad_value);
4182           ret_val = FALSE;
4183           continue;
4184         }
4185
4186       r_symndx = ELF64_R_SYM(rel->r_info);
4187
4188       /* The symbol associated with GPDISP and LITUSE is
4189          immaterial.  Only the addend is significant.  */
4190       if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4191         continue;
4192
4193       if (r_symndx < symtab_hdr_sh_info)
4194         {
4195           sym = local_syms + r_symndx;
4196           if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
4197             {
4198               sec = local_sections[r_symndx];
4199               rel->r_addend += sec->output_offset + sym->st_value;
4200             }
4201         }
4202     }
4203
4204   return ret_val;
4205 }
4206
4207 /* Relocate an Alpha ELF section.  */
4208
4209 static bfd_boolean
4210 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
4211                               contents, relocs, local_syms, local_sections)
4212      bfd *output_bfd;
4213      struct bfd_link_info *info;
4214      bfd *input_bfd;
4215      asection *input_section;
4216      bfd_byte *contents;
4217      Elf_Internal_Rela *relocs;
4218      Elf_Internal_Sym *local_syms;
4219      asection **local_sections;
4220 {
4221   Elf_Internal_Shdr *symtab_hdr;
4222   Elf_Internal_Rela *rel;
4223   Elf_Internal_Rela *relend;
4224   asection *sgot, *srel, *srelgot;
4225   bfd *dynobj, *gotobj;
4226   bfd_vma gp, tp_base, dtp_base;
4227   struct alpha_elf_got_entry **local_got_entries;
4228   bfd_boolean ret_val;
4229   const char *section_name;
4230
4231   /* Handle relocatable links with a smaller loop.  */
4232   if (info->relocatable)
4233     return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4234                                            input_section, contents, relocs,
4235                                            local_syms, local_sections);
4236
4237   /* This is a final link.  */
4238
4239   ret_val = TRUE;
4240
4241   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4242
4243   dynobj = elf_hash_table (info)->dynobj;
4244   if (dynobj)
4245     srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4246   else
4247     srelgot = NULL;
4248
4249   section_name = (bfd_elf_string_from_elf_section
4250                   (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4251                    elf_section_data(input_section)->rel_hdr.sh_name));
4252   BFD_ASSERT(section_name != NULL);
4253   srel = bfd_get_section_by_name (dynobj, section_name);
4254
4255   /* Find the gp value for this input bfd.  */
4256   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4257   if (gotobj)
4258     {
4259       sgot = alpha_elf_tdata (gotobj)->got;
4260       gp = _bfd_get_gp_value (gotobj);
4261       if (gp == 0)
4262         {
4263           gp = (sgot->output_section->vma
4264                 + sgot->output_offset
4265                 + 0x8000);
4266           _bfd_set_gp_value (gotobj, gp);
4267         }
4268     }
4269   else
4270     {
4271       sgot = NULL;
4272       gp = 0;
4273     }
4274
4275   local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4276
4277   if (elf_hash_table (info)->tls_sec != NULL)
4278     {
4279       dtp_base = alpha_get_dtprel_base (info);
4280       tp_base = alpha_get_tprel_base (info);
4281     }
4282   else
4283     dtp_base = tp_base = 0;
4284
4285   relend = relocs + input_section->reloc_count;
4286   for (rel = relocs; rel < relend; rel++)
4287     {
4288       struct alpha_elf_link_hash_entry *h = NULL;
4289       struct alpha_elf_got_entry *gotent;
4290       bfd_reloc_status_type r;
4291       reloc_howto_type *howto;
4292       unsigned long r_symndx;
4293       Elf_Internal_Sym *sym = NULL;
4294       asection *sec = NULL;
4295       bfd_vma value;
4296       bfd_vma addend;
4297       bfd_boolean dynamic_symbol_p;
4298       bfd_boolean undef_weak_ref = FALSE;
4299       unsigned long r_type;
4300
4301       r_type = ELF64_R_TYPE(rel->r_info);
4302       if (r_type >= R_ALPHA_max)
4303         {
4304           (*_bfd_error_handler)
4305             (_("%B: unknown relocation type %d"),
4306              input_bfd, (int) r_type);
4307           bfd_set_error (bfd_error_bad_value);
4308           ret_val = FALSE;
4309           continue;
4310         }
4311
4312       howto = elf64_alpha_howto_table + r_type;
4313       r_symndx = ELF64_R_SYM(rel->r_info);
4314
4315       /* The symbol for a TLSLDM reloc is ignored.  Collapse the
4316          reloc to the 0 symbol so that they all match.  */
4317       if (r_type == R_ALPHA_TLSLDM)
4318         r_symndx = 0;
4319
4320       if (r_symndx < symtab_hdr->sh_info)
4321         {
4322           asection *msec;
4323           sym = local_syms + r_symndx;
4324           sec = local_sections[r_symndx];
4325           msec = sec;
4326           value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4327
4328           /* If this is a tp-relative relocation against sym 0,
4329              this is hackery from relax_section.  Force the value to
4330              be the tls base.  */
4331           if (r_symndx == 0
4332               && (r_type == R_ALPHA_TLSLDM
4333                   || r_type == R_ALPHA_GOTTPREL
4334                   || r_type == R_ALPHA_TPREL64
4335                   || r_type == R_ALPHA_TPRELHI
4336                   || r_type == R_ALPHA_TPRELLO
4337                   || r_type == R_ALPHA_TPREL16))
4338             value = tp_base;
4339
4340           if (local_got_entries)
4341             gotent = local_got_entries[r_symndx];
4342           else
4343             gotent = NULL;
4344
4345           /* Need to adjust local GOT entries' addends for SEC_MERGE
4346              unless it has been done already.  */
4347           if ((sec->flags & SEC_MERGE)
4348               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4349               && sec->sec_info_type == ELF_INFO_TYPE_MERGE
4350               && gotent
4351               && !gotent->reloc_xlated)
4352             {
4353               struct alpha_elf_got_entry *ent;
4354
4355               for (ent = gotent; ent; ent = ent->next)
4356                 {
4357                   ent->reloc_xlated = 1;
4358                   if (ent->use_count == 0)
4359                     continue;
4360                   msec = sec;
4361                   ent->addend =
4362                     _bfd_merged_section_offset (output_bfd, &msec,
4363                                                 elf_section_data (sec)->
4364                                                   sec_info,
4365                                                 sym->st_value + ent->addend);
4366                   ent->addend -= sym->st_value;
4367                   ent->addend += msec->output_section->vma
4368                                  + msec->output_offset
4369                                  - sec->output_section->vma
4370                                  - sec->output_offset;
4371                 }
4372             }
4373
4374           dynamic_symbol_p = FALSE;
4375         }
4376       else
4377         {
4378           bfd_boolean warned;
4379           bfd_boolean unresolved_reloc;
4380           struct elf_link_hash_entry *hh;
4381           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4382
4383           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4384                                    r_symndx, symtab_hdr, sym_hashes,
4385                                    hh, sec, value,
4386                                    unresolved_reloc, warned);
4387
4388           if (warned)
4389             continue;
4390
4391           if (value == 0
4392               && ! unresolved_reloc
4393               && hh->root.type == bfd_link_hash_undefweak)
4394             undef_weak_ref = TRUE;
4395
4396           h = (struct alpha_elf_link_hash_entry *) hh;
4397           dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4398           gotent = h->got_entries;
4399         }
4400
4401       addend = rel->r_addend;
4402       value += addend;
4403
4404       /* Search for the proper got entry.  */
4405       for (; gotent ; gotent = gotent->next)
4406         if (gotent->gotobj == gotobj
4407             && gotent->reloc_type == r_type
4408             && gotent->addend == addend)
4409           break;
4410
4411       switch (r_type)
4412         {
4413         case R_ALPHA_GPDISP:
4414           {
4415             bfd_byte *p_ldah, *p_lda;
4416
4417             BFD_ASSERT(gp != 0);
4418
4419             value = (input_section->output_section->vma
4420                      + input_section->output_offset
4421                      + rel->r_offset);
4422
4423             p_ldah = contents + rel->r_offset;
4424             p_lda = p_ldah + rel->r_addend;
4425
4426             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4427                                              p_ldah, p_lda);
4428           }
4429           break;
4430
4431         case R_ALPHA_LITERAL:
4432           BFD_ASSERT(sgot != NULL);
4433           BFD_ASSERT(gp != 0);
4434           BFD_ASSERT(gotent != NULL);
4435           BFD_ASSERT(gotent->use_count >= 1);
4436
4437           if (!gotent->reloc_done)
4438             {
4439               gotent->reloc_done = 1;
4440
4441               bfd_put_64 (output_bfd, value,
4442                           sgot->contents + gotent->got_offset);
4443
4444               /* If the symbol has been forced local, output a
4445                  RELATIVE reloc, otherwise it will be handled in
4446                  finish_dynamic_symbol.  */
4447               if (info->shared && !dynamic_symbol_p)
4448                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4449                                          gotent->got_offset, 0,
4450                                          R_ALPHA_RELATIVE, value);
4451             }
4452
4453           value = (sgot->output_section->vma
4454                    + sgot->output_offset
4455                    + gotent->got_offset);
4456           value -= gp;
4457           goto default_reloc;
4458
4459         case R_ALPHA_GPREL32:
4460           /* If the target section was a removed linkonce section,
4461              r_symndx will be zero.  In this case, assume that the
4462              switch will not be used, so don't fill it in.  If we
4463              do nothing here, we'll get relocation truncated messages,
4464              due to the placement of the application above 4GB.  */
4465           if (r_symndx == 0)
4466             {
4467               r = bfd_reloc_ok;
4468               break;
4469             }
4470           /* FALLTHRU */
4471
4472         case R_ALPHA_GPREL16:
4473         case R_ALPHA_GPRELLOW:
4474           if (dynamic_symbol_p)
4475             {
4476               (*_bfd_error_handler)
4477                 (_("%B: gp-relative relocation against dynamic symbol %s"),
4478                  input_bfd, h->root.root.root.string);
4479               ret_val = FALSE;
4480             }
4481           BFD_ASSERT(gp != 0);
4482           value -= gp;
4483           goto default_reloc;
4484
4485         case R_ALPHA_GPRELHIGH:
4486           if (dynamic_symbol_p)
4487             {
4488               (*_bfd_error_handler)
4489                 (_("%B: gp-relative relocation against dynamic symbol %s"),
4490                  input_bfd, h->root.root.root.string);
4491               ret_val = FALSE;
4492             }
4493           BFD_ASSERT(gp != 0);
4494           value -= gp;
4495           value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4496           goto default_reloc;
4497
4498         case R_ALPHA_HINT:
4499           /* A call to a dynamic symbol is definitely out of range of
4500              the 16-bit displacement.  Don't bother writing anything.  */
4501           if (dynamic_symbol_p)
4502             {
4503               r = bfd_reloc_ok;
4504               break;
4505             }
4506           /* The regular PC-relative stuff measures from the start of
4507              the instruction rather than the end.  */
4508           value -= 4;
4509           goto default_reloc;
4510
4511         case R_ALPHA_BRADDR:
4512           if (dynamic_symbol_p)
4513             {
4514               (*_bfd_error_handler)
4515                 (_("%B: pc-relative relocation against dynamic symbol %s"),
4516                  input_bfd, h->root.root.root.string);
4517               ret_val = FALSE;
4518             }
4519           /* The regular PC-relative stuff measures from the start of
4520              the instruction rather than the end.  */
4521           value -= 4;
4522           goto default_reloc;
4523
4524         case R_ALPHA_BRSGP:
4525           {
4526             int other;
4527             const char *name;
4528
4529             /* The regular PC-relative stuff measures from the start of
4530                the instruction rather than the end.  */
4531             value -= 4;
4532
4533             /* The source and destination gp must be the same.  Note that
4534                the source will always have an assigned gp, since we forced
4535                one in check_relocs, but that the destination may not, as
4536                it might not have had any relocations at all.  Also take
4537                care not to crash if H is an undefined symbol.  */
4538             if (h != NULL && sec != NULL
4539                 && alpha_elf_tdata (sec->owner)->gotobj
4540                 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4541               {
4542                 (*_bfd_error_handler)
4543                   (_("%B: change in gp: BRSGP %s"),
4544                    input_bfd, h->root.root.root.string);
4545                 ret_val = FALSE;
4546               }
4547
4548             /* The symbol should be marked either NOPV or STD_GPLOAD.  */
4549             if (h != NULL)
4550               other = h->root.other;
4551             else
4552               other = sym->st_other;
4553             switch (other & STO_ALPHA_STD_GPLOAD)
4554               {
4555               case STO_ALPHA_NOPV:
4556                 break;
4557               case STO_ALPHA_STD_GPLOAD:
4558                 value += 8;
4559                 break;
4560               default:
4561                 if (h != NULL)
4562                   name = h->root.root.root.string;
4563                 else
4564                   {
4565                     name = (bfd_elf_string_from_elf_section
4566                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
4567                     if (name == NULL)
4568                       name = _("<unknown>");
4569                     else if (name[0] == 0)
4570                       name = bfd_section_name (input_bfd, sec);
4571                   }
4572                 (*_bfd_error_handler)
4573                   (_("%B: !samegp reloc against symbol without .prologue: %s"),
4574                    input_bfd, name);
4575                 ret_val = FALSE;
4576                 break;
4577               }
4578
4579             goto default_reloc;
4580           }
4581
4582         case R_ALPHA_REFLONG:
4583         case R_ALPHA_REFQUAD:
4584         case R_ALPHA_DTPREL64:
4585         case R_ALPHA_TPREL64:
4586           {
4587             long dynindx, dyntype = r_type;
4588             bfd_vma dynaddend;
4589
4590             /* Careful here to remember RELATIVE relocations for global
4591                variables for symbolic shared objects.  */
4592
4593             if (dynamic_symbol_p)
4594               {
4595                 BFD_ASSERT(h->root.dynindx != -1);
4596                 dynindx = h->root.dynindx;
4597                 dynaddend = addend;
4598                 addend = 0, value = 0;
4599               }
4600             else if (r_type == R_ALPHA_DTPREL64)
4601               {
4602                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4603                 value -= dtp_base;
4604                 goto default_reloc;
4605               }
4606             else if (r_type == R_ALPHA_TPREL64)
4607               {
4608                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4609                 if (!info->shared)
4610                   {
4611                     value -= tp_base;
4612                     goto default_reloc;
4613                   }
4614                 dynindx = 0;
4615                 dynaddend = value - dtp_base;
4616               }
4617             else if (info->shared
4618                      && r_symndx != 0
4619                      && (input_section->flags & SEC_ALLOC))
4620               {
4621                 if (r_type == R_ALPHA_REFLONG)
4622                   {
4623                     (*_bfd_error_handler)
4624                       (_("%B: unhandled dynamic relocation against %s"),
4625                        input_bfd,
4626                        h->root.root.root.string);
4627                     ret_val = FALSE;
4628                   }
4629                 dynindx = 0;
4630                 dyntype = R_ALPHA_RELATIVE;
4631                 dynaddend = value;
4632               }
4633             else
4634               goto default_reloc;
4635
4636             elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4637                                      srel, rel->r_offset, dynindx,
4638                                      dyntype, dynaddend);
4639           }
4640           goto default_reloc;
4641
4642         case R_ALPHA_SREL16:
4643         case R_ALPHA_SREL32:
4644         case R_ALPHA_SREL64:
4645           if (dynamic_symbol_p)
4646             {
4647               (*_bfd_error_handler)
4648                 (_("%B: pc-relative relocation against dynamic symbol %s"),
4649                  input_bfd, h->root.root.root.string);
4650               ret_val = FALSE;
4651             }
4652
4653           /* ??? .eh_frame references to discarded sections will be smashed
4654              to relocations against SHN_UNDEF.  The .eh_frame format allows
4655              NULL to be encoded as 0 in any format, so this works here.  */
4656           if (r_symndx == 0)
4657             howto = (elf64_alpha_howto_table
4658                      + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4659           goto default_reloc;
4660
4661         case R_ALPHA_TLSLDM:
4662           /* Ignore the symbol for the relocation.  The result is always
4663              the current module.  */
4664           dynamic_symbol_p = 0;
4665           /* FALLTHRU */
4666
4667         case R_ALPHA_TLSGD:
4668           if (!gotent->reloc_done)
4669             {
4670               gotent->reloc_done = 1;
4671
4672               /* Note that the module index for the main program is 1.  */
4673               bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4674                           sgot->contents + gotent->got_offset);
4675
4676               /* If the symbol has been forced local, output a
4677                  DTPMOD64 reloc, otherwise it will be handled in
4678                  finish_dynamic_symbol.  */
4679               if (info->shared && !dynamic_symbol_p)
4680                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4681                                          gotent->got_offset, 0,
4682                                          R_ALPHA_DTPMOD64, 0);
4683
4684               if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4685                 value = 0;
4686               else
4687                 {
4688                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4689                   value -= dtp_base;
4690                 }
4691               bfd_put_64 (output_bfd, value,
4692                           sgot->contents + gotent->got_offset + 8);
4693             }
4694
4695           value = (sgot->output_section->vma
4696                    + sgot->output_offset
4697                    + gotent->got_offset);
4698           value -= gp;
4699           goto default_reloc;
4700
4701         case R_ALPHA_DTPRELHI:
4702         case R_ALPHA_DTPRELLO:
4703         case R_ALPHA_DTPREL16:
4704           if (dynamic_symbol_p)
4705             {
4706               (*_bfd_error_handler)
4707                 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4708                  input_bfd, h->root.root.root.string);
4709               ret_val = FALSE;
4710             }
4711           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4712           value -= dtp_base;
4713           if (r_type == R_ALPHA_DTPRELHI)
4714             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4715           goto default_reloc;
4716
4717         case R_ALPHA_TPRELHI:
4718         case R_ALPHA_TPRELLO:
4719         case R_ALPHA_TPREL16:
4720           if (info->shared)
4721             {
4722               (*_bfd_error_handler)
4723                 (_("%B: TLS local exec code cannot be linked into shared objects"),
4724                 input_bfd);
4725               ret_val = FALSE;
4726             }
4727           else if (dynamic_symbol_p)
4728             {
4729               (*_bfd_error_handler)
4730                 (_("%B: tp-relative relocation against dynamic symbol %s"),
4731                  input_bfd, h->root.root.root.string);
4732               ret_val = FALSE;
4733             }
4734           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4735           value -= tp_base;
4736           if (r_type == R_ALPHA_TPRELHI)
4737             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4738           goto default_reloc;
4739
4740         case R_ALPHA_GOTDTPREL:
4741         case R_ALPHA_GOTTPREL:
4742           BFD_ASSERT(sgot != NULL);
4743           BFD_ASSERT(gp != 0);
4744           BFD_ASSERT(gotent != NULL);
4745           BFD_ASSERT(gotent->use_count >= 1);
4746
4747           if (!gotent->reloc_done)
4748             {
4749               gotent->reloc_done = 1;
4750
4751               if (dynamic_symbol_p)
4752                 value = 0;
4753               else
4754                 {
4755                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4756                   if (r_type == R_ALPHA_GOTDTPREL)
4757                     value -= dtp_base;
4758                   else if (!info->shared)
4759                     value -= tp_base;
4760                   else
4761                     {
4762                       elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4763                                                gotent->got_offset, 0,
4764                                                R_ALPHA_TPREL64,
4765                                                value - dtp_base);
4766                       value = 0;
4767                     }
4768                 }
4769               bfd_put_64 (output_bfd, value,
4770                           sgot->contents + gotent->got_offset);
4771             }
4772
4773           value = (sgot->output_section->vma
4774                    + sgot->output_offset
4775                    + gotent->got_offset);
4776           value -= gp;
4777           goto default_reloc;
4778
4779         default:
4780         default_reloc:
4781           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4782                                         contents, rel->r_offset, value, 0);
4783           break;
4784         }
4785
4786       switch (r)
4787         {
4788         case bfd_reloc_ok:
4789           break;
4790
4791         case bfd_reloc_overflow:
4792           {
4793             const char *name;
4794
4795             /* Don't warn if the overflow is due to pc relative reloc
4796                against discarded section.  Section optimization code should
4797                handle it.  */
4798
4799             if (r_symndx < symtab_hdr->sh_info
4800                 && sec != NULL && howto->pc_relative
4801                 && elf_discarded_section (sec))
4802               break;
4803
4804             if (h != NULL)
4805               name = h->root.root.root.string;
4806             else
4807               {
4808                 name = (bfd_elf_string_from_elf_section
4809                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
4810                 if (name == NULL)
4811                   return FALSE;
4812                 if (*name == '\0')
4813                   name = bfd_section_name (input_bfd, sec);
4814               }
4815             if (! ((*info->callbacks->reloc_overflow)
4816                    (info, name, howto->name, (bfd_vma) 0,
4817                     input_bfd, input_section, rel->r_offset)))
4818               ret_val = FALSE;
4819           }
4820           break;
4821
4822         default:
4823         case bfd_reloc_outofrange:
4824           abort ();
4825         }
4826     }
4827
4828   return ret_val;
4829 }
4830
4831 /* Finish up dynamic symbol handling.  We set the contents of various
4832    dynamic sections here.  */
4833
4834 static bfd_boolean
4835 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
4836      bfd *output_bfd;
4837      struct bfd_link_info *info;
4838      struct elf_link_hash_entry *h;
4839      Elf_Internal_Sym *sym;
4840 {
4841   bfd *dynobj = elf_hash_table(info)->dynobj;
4842
4843   if (h->plt.offset != MINUS_ONE)
4844     {
4845       /* Fill in the .plt entry for this symbol.  */
4846       asection *splt, *sgot, *srel;
4847       Elf_Internal_Rela outrel;
4848       bfd_byte *loc;
4849       bfd_vma got_addr, plt_addr;
4850       bfd_vma plt_index;
4851       struct alpha_elf_got_entry *gotent;
4852
4853       BFD_ASSERT (h->dynindx != -1);
4854
4855       /* The first .got entry will be updated by the .plt with the
4856          address of the target function.  */
4857       gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4858       BFD_ASSERT (gotent && gotent->addend == 0);
4859
4860       splt = bfd_get_section_by_name (dynobj, ".plt");
4861       BFD_ASSERT (splt != NULL);
4862       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4863       BFD_ASSERT (srel != NULL);
4864       sgot = alpha_elf_tdata (gotent->gotobj)->got;
4865       BFD_ASSERT (sgot != NULL);
4866
4867       got_addr = (sgot->output_section->vma
4868                   + sgot->output_offset
4869                   + gotent->got_offset);
4870       plt_addr = (splt->output_section->vma
4871                   + splt->output_offset
4872                   + h->plt.offset);
4873
4874       plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4875
4876       /* Fill in the entry in the procedure linkage table.  */
4877       {
4878         bfd_vma insn1, insn2, insn3;
4879
4880         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
4881         insn2 = PLT_ENTRY_WORD2;
4882         insn3 = PLT_ENTRY_WORD3;
4883
4884         bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
4885         bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
4886         bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
4887       }
4888
4889       /* Fill in the entry in the .rela.plt section.  */
4890       outrel.r_offset = got_addr;
4891       outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4892       outrel.r_addend = 0;
4893
4894       loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4895       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4896
4897       if (!h->def_regular)
4898         {
4899           /* Mark the symbol as undefined, rather than as defined in the
4900              .plt section.  Leave the value alone.  */
4901           sym->st_shndx = SHN_UNDEF;
4902         }
4903
4904       /* Fill in the entries in the .got.  */
4905       bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
4906
4907       /* Subsequent .got entries will continue to bounce through the .plt.  */
4908       if (gotent->next)
4909         {
4910           srel = bfd_get_section_by_name (dynobj, ".rela.got");
4911           BFD_ASSERT (! info->shared || srel != NULL);
4912
4913           gotent = gotent->next;
4914           do
4915             {
4916               sgot = alpha_elf_tdata(gotent->gotobj)->got;
4917               BFD_ASSERT(sgot != NULL);
4918               BFD_ASSERT(gotent->addend == 0);
4919
4920               bfd_put_64 (output_bfd, plt_addr,
4921                           sgot->contents + gotent->got_offset);
4922
4923               if (info->shared)
4924                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4925                                          gotent->got_offset, 0,
4926                                          R_ALPHA_RELATIVE, plt_addr);
4927
4928               gotent = gotent->next;
4929             }
4930           while (gotent != NULL);
4931         }
4932     }
4933   else if (alpha_elf_dynamic_symbol_p (h, info))
4934     {
4935       /* Fill in the dynamic relocations for this symbol's .got entries.  */
4936       asection *srel;
4937       struct alpha_elf_got_entry *gotent;
4938
4939       srel = bfd_get_section_by_name (dynobj, ".rela.got");
4940       BFD_ASSERT (srel != NULL);
4941
4942       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4943            gotent != NULL;
4944            gotent = gotent->next)
4945         {
4946           asection *sgot;
4947           long r_type;
4948
4949           if (gotent->use_count == 0)
4950             continue;
4951
4952           sgot = alpha_elf_tdata (gotent->gotobj)->got;
4953
4954           r_type = gotent->reloc_type;
4955           switch (r_type)
4956             {
4957             case R_ALPHA_LITERAL:
4958               r_type = R_ALPHA_GLOB_DAT;
4959               break;
4960             case R_ALPHA_TLSGD:
4961               r_type = R_ALPHA_DTPMOD64;
4962               break;
4963             case R_ALPHA_GOTDTPREL:
4964               r_type = R_ALPHA_DTPREL64;
4965               break;
4966             case R_ALPHA_GOTTPREL:
4967               r_type = R_ALPHA_TPREL64;
4968               break;
4969             case R_ALPHA_TLSLDM:
4970             default:
4971               abort ();
4972             }
4973
4974           elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4975                                    gotent->got_offset, h->dynindx,
4976                                    r_type, gotent->addend);
4977
4978           if (gotent->reloc_type == R_ALPHA_TLSGD)
4979             elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4980                                      gotent->got_offset + 8, h->dynindx,
4981                                      R_ALPHA_DTPREL64, gotent->addend);
4982         }
4983     }
4984
4985   /* Mark some specially defined symbols as absolute.  */
4986   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4987       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4988       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4989     sym->st_shndx = SHN_ABS;
4990
4991   return TRUE;
4992 }
4993
4994 /* Finish up the dynamic sections.  */
4995
4996 static bfd_boolean
4997 elf64_alpha_finish_dynamic_sections (output_bfd, info)
4998      bfd *output_bfd;
4999      struct bfd_link_info *info;
5000 {
5001   bfd *dynobj;
5002   asection *sdyn;
5003
5004   dynobj = elf_hash_table (info)->dynobj;
5005   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5006
5007   if (elf_hash_table (info)->dynamic_sections_created)
5008     {
5009       asection *splt;
5010       Elf64_External_Dyn *dyncon, *dynconend;
5011
5012       splt = bfd_get_section_by_name (dynobj, ".plt");
5013       BFD_ASSERT (splt != NULL && sdyn != NULL);
5014
5015       dyncon = (Elf64_External_Dyn *) sdyn->contents;
5016       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5017       for (; dyncon < dynconend; dyncon++)
5018         {
5019           Elf_Internal_Dyn dyn;
5020           const char *name;
5021           asection *s;
5022
5023           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5024
5025           switch (dyn.d_tag)
5026             {
5027             case DT_PLTGOT:
5028               name = ".plt";
5029               goto get_vma;
5030             case DT_PLTRELSZ:
5031               name = ".rela.plt";
5032               goto get_size;
5033             case DT_JMPREL:
5034               name = ".rela.plt";
5035               goto get_vma;
5036
5037             case DT_RELASZ:
5038               /* My interpretation of the TIS v1.1 ELF document indicates
5039                  that RELASZ should not include JMPREL.  This is not what
5040                  the rest of the BFD does.  It is, however, what the
5041                  glibc ld.so wants.  Do this fixup here until we found
5042                  out who is right.  */
5043               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5044               if (s)
5045                 dyn.d_un.d_val -= s->size;
5046               break;
5047
5048             get_vma:
5049               s = bfd_get_section_by_name (output_bfd, name);
5050               dyn.d_un.d_ptr = (s ? s->vma : 0);
5051               break;
5052
5053             get_size:
5054               s = bfd_get_section_by_name (output_bfd, name);
5055               dyn.d_un.d_val = s->size;
5056               break;
5057             }
5058
5059           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5060         }
5061
5062       /* Initialize the PLT0 entry.  */
5063       if (splt->size > 0)
5064         {
5065           bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
5066           bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
5067           bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
5068           bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
5069
5070           /* The next two words will be filled in by ld.so */
5071           bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
5072           bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
5073
5074           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5075         }
5076     }
5077
5078   return TRUE;
5079 }
5080
5081 /* We need to use a special link routine to handle the .mdebug section.
5082    We need to merge all instances of these sections together, not write
5083    them all out sequentially.  */
5084
5085 static bfd_boolean
5086 elf64_alpha_final_link (abfd, info)
5087      bfd *abfd;
5088      struct bfd_link_info *info;
5089 {
5090   asection *o;
5091   struct bfd_link_order *p;
5092   asection *mdebug_sec;
5093   struct ecoff_debug_info debug;
5094   const struct ecoff_debug_swap *swap
5095     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5096   HDRR *symhdr = &debug.symbolic_header;
5097   PTR mdebug_handle = NULL;
5098
5099   /* Go through the sections and collect the mdebug information.  */
5100   mdebug_sec = NULL;
5101   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5102     {
5103       if (strcmp (o->name, ".mdebug") == 0)
5104         {
5105           struct extsym_info einfo;
5106
5107           /* We have found the .mdebug section in the output file.
5108              Look through all the link_orders comprising it and merge
5109              the information together.  */
5110           symhdr->magic = swap->sym_magic;
5111           /* FIXME: What should the version stamp be?  */
5112           symhdr->vstamp = 0;
5113           symhdr->ilineMax = 0;
5114           symhdr->cbLine = 0;
5115           symhdr->idnMax = 0;
5116           symhdr->ipdMax = 0;
5117           symhdr->isymMax = 0;
5118           symhdr->ioptMax = 0;
5119           symhdr->iauxMax = 0;
5120           symhdr->issMax = 0;
5121           symhdr->issExtMax = 0;
5122           symhdr->ifdMax = 0;
5123           symhdr->crfd = 0;
5124           symhdr->iextMax = 0;
5125
5126           /* We accumulate the debugging information itself in the
5127              debug_info structure.  */
5128           debug.line = NULL;
5129           debug.external_dnr = NULL;
5130           debug.external_pdr = NULL;
5131           debug.external_sym = NULL;
5132           debug.external_opt = NULL;
5133           debug.external_aux = NULL;
5134           debug.ss = NULL;
5135           debug.ssext = debug.ssext_end = NULL;
5136           debug.external_fdr = NULL;
5137           debug.external_rfd = NULL;
5138           debug.external_ext = debug.external_ext_end = NULL;
5139
5140           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5141           if (mdebug_handle == (PTR) NULL)
5142             return FALSE;
5143
5144           if (1)
5145             {
5146               asection *s;
5147               EXTR esym;
5148               bfd_vma last = 0;
5149               unsigned int i;
5150               static const char * const name[] =
5151                 {
5152                   ".text", ".init", ".fini", ".data",
5153                   ".rodata", ".sdata", ".sbss", ".bss"
5154                 };
5155               static const int sc[] = { scText, scInit, scFini, scData,
5156                                           scRData, scSData, scSBss, scBss };
5157
5158               esym.jmptbl = 0;
5159               esym.cobol_main = 0;
5160               esym.weakext = 0;
5161               esym.reserved = 0;
5162               esym.ifd = ifdNil;
5163               esym.asym.iss = issNil;
5164               esym.asym.st = stLocal;
5165               esym.asym.reserved = 0;
5166               esym.asym.index = indexNil;
5167               for (i = 0; i < 8; i++)
5168                 {
5169                   esym.asym.sc = sc[i];
5170                   s = bfd_get_section_by_name (abfd, name[i]);
5171                   if (s != NULL)
5172                     {
5173                       esym.asym.value = s->vma;
5174                       last = s->vma + s->size;
5175                     }
5176                   else
5177                     esym.asym.value = last;
5178
5179                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5180                                                       name[i], &esym))
5181                     return FALSE;
5182                 }
5183             }
5184
5185           for (p = o->link_order_head;
5186                p != (struct bfd_link_order *) NULL;
5187                p = p->next)
5188             {
5189               asection *input_section;
5190               bfd *input_bfd;
5191               const struct ecoff_debug_swap *input_swap;
5192               struct ecoff_debug_info input_debug;
5193               char *eraw_src;
5194               char *eraw_end;
5195
5196               if (p->type != bfd_indirect_link_order)
5197                 {
5198                   if (p->type == bfd_data_link_order)
5199                     continue;
5200                   abort ();
5201                 }
5202
5203               input_section = p->u.indirect.section;
5204               input_bfd = input_section->owner;
5205
5206               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
5207                   || (get_elf_backend_data (input_bfd)
5208                       ->elf_backend_ecoff_debug_swap) == NULL)
5209                 {
5210                   /* I don't know what a non ALPHA ELF bfd would be
5211                      doing with a .mdebug section, but I don't really
5212                      want to deal with it.  */
5213                   continue;
5214                 }
5215
5216               input_swap = (get_elf_backend_data (input_bfd)
5217                             ->elf_backend_ecoff_debug_swap);
5218
5219               BFD_ASSERT (p->size == input_section->size);
5220
5221               /* The ECOFF linking code expects that we have already
5222                  read in the debugging information and set up an
5223                  ecoff_debug_info structure, so we do that now.  */
5224               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5225                                                 &input_debug))
5226                 return FALSE;
5227
5228               if (! (bfd_ecoff_debug_accumulate
5229                      (mdebug_handle, abfd, &debug, swap, input_bfd,
5230                       &input_debug, input_swap, info)))
5231                 return FALSE;
5232
5233               /* Loop through the external symbols.  For each one with
5234                  interesting information, try to find the symbol in
5235                  the linker global hash table and save the information
5236                  for the output external symbols.  */
5237               eraw_src = input_debug.external_ext;
5238               eraw_end = (eraw_src
5239                           + (input_debug.symbolic_header.iextMax
5240                              * input_swap->external_ext_size));
5241               for (;
5242                    eraw_src < eraw_end;
5243                    eraw_src += input_swap->external_ext_size)
5244                 {
5245                   EXTR ext;
5246                   const char *name;
5247                   struct alpha_elf_link_hash_entry *h;
5248
5249                   (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
5250                   if (ext.asym.sc == scNil
5251                       || ext.asym.sc == scUndefined
5252                       || ext.asym.sc == scSUndefined)
5253                     continue;
5254
5255                   name = input_debug.ssext + ext.asym.iss;
5256                   h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
5257                                                   name, FALSE, FALSE, TRUE);
5258                   if (h == NULL || h->esym.ifd != -2)
5259                     continue;
5260
5261                   if (ext.ifd != -1)
5262                     {
5263                       BFD_ASSERT (ext.ifd
5264                                   < input_debug.symbolic_header.ifdMax);
5265                       ext.ifd = input_debug.ifdmap[ext.ifd];
5266                     }
5267
5268                   h->esym = ext;
5269                 }
5270
5271               /* Free up the information we just read.  */
5272               free (input_debug.line);
5273               free (input_debug.external_dnr);
5274               free (input_debug.external_pdr);
5275               free (input_debug.external_sym);
5276               free (input_debug.external_opt);
5277               free (input_debug.external_aux);
5278               free (input_debug.ss);
5279               free (input_debug.ssext);
5280               free (input_debug.external_fdr);
5281               free (input_debug.external_rfd);
5282               free (input_debug.external_ext);
5283
5284               /* Hack: reset the SEC_HAS_CONTENTS flag so that
5285                  elf_link_input_bfd ignores this section.  */
5286               input_section->flags &=~ SEC_HAS_CONTENTS;
5287             }
5288
5289           /* Build the external symbol information.  */
5290           einfo.abfd = abfd;
5291           einfo.info = info;
5292           einfo.debug = &debug;
5293           einfo.swap = swap;
5294           einfo.failed = FALSE;
5295           elf_link_hash_traverse (elf_hash_table (info),
5296                                   elf64_alpha_output_extsym,
5297                                   (PTR) &einfo);
5298           if (einfo.failed)
5299             return FALSE;
5300
5301           /* Set the size of the .mdebug section.  */
5302           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5303
5304           /* Skip this section later on (I don't think this currently
5305              matters, but someday it might).  */
5306           o->link_order_head = (struct bfd_link_order *) NULL;
5307
5308           mdebug_sec = o;
5309         }
5310     }
5311
5312   /* Invoke the regular ELF backend linker to do all the work.  */
5313   if (! bfd_elf_final_link (abfd, info))
5314     return FALSE;
5315
5316   /* Now write out the computed sections.  */
5317
5318   /* The .got subsections...  */
5319   {
5320     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5321     for (i = alpha_elf_hash_table(info)->got_list;
5322          i != NULL;
5323          i = alpha_elf_tdata(i)->got_link_next)
5324       {
5325         asection *sgot;
5326
5327         /* elf_bfd_final_link already did everything in dynobj.  */
5328         if (i == dynobj)
5329           continue;
5330
5331         sgot = alpha_elf_tdata(i)->got;
5332         if (! bfd_set_section_contents (abfd, sgot->output_section,
5333                                         sgot->contents,
5334                                         (file_ptr) sgot->output_offset,
5335                                         sgot->size))
5336           return FALSE;
5337       }
5338   }
5339
5340   if (mdebug_sec != (asection *) NULL)
5341     {
5342       BFD_ASSERT (abfd->output_has_begun);
5343       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5344                                                swap, info,
5345                                                mdebug_sec->filepos))
5346         return FALSE;
5347
5348       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5349     }
5350
5351   return TRUE;
5352 }
5353
5354 static enum elf_reloc_type_class
5355 elf64_alpha_reloc_type_class (rela)
5356      const Elf_Internal_Rela *rela;
5357 {
5358   switch ((int) ELF64_R_TYPE (rela->r_info))
5359     {
5360     case R_ALPHA_RELATIVE:
5361       return reloc_class_relative;
5362     case R_ALPHA_JMP_SLOT:
5363       return reloc_class_plt;
5364     case R_ALPHA_COPY:
5365       return reloc_class_copy;
5366     default:
5367       return reloc_class_normal;
5368     }
5369 }
5370 \f
5371 static struct bfd_elf_special_section const elf64_alpha_special_sections[]=
5372 {
5373   { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5374   { ".sbss",  5, -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5375   { NULL,     0,  0, 0,            0 }
5376 };
5377
5378 /* ECOFF swapping routines.  These are used when dealing with the
5379    .mdebug section, which is in the ECOFF debugging format.  Copied
5380    from elf32-mips.c.  */
5381 static const struct ecoff_debug_swap
5382 elf64_alpha_ecoff_debug_swap =
5383 {
5384   /* Symbol table magic number.  */
5385   magicSym2,
5386   /* Alignment of debugging information.  E.g., 4.  */
5387   8,
5388   /* Sizes of external symbolic information.  */
5389   sizeof (struct hdr_ext),
5390   sizeof (struct dnr_ext),
5391   sizeof (struct pdr_ext),
5392   sizeof (struct sym_ext),
5393   sizeof (struct opt_ext),
5394   sizeof (struct fdr_ext),
5395   sizeof (struct rfd_ext),
5396   sizeof (struct ext_ext),
5397   /* Functions to swap in external symbolic data.  */
5398   ecoff_swap_hdr_in,
5399   ecoff_swap_dnr_in,
5400   ecoff_swap_pdr_in,
5401   ecoff_swap_sym_in,
5402   ecoff_swap_opt_in,
5403   ecoff_swap_fdr_in,
5404   ecoff_swap_rfd_in,
5405   ecoff_swap_ext_in,
5406   _bfd_ecoff_swap_tir_in,
5407   _bfd_ecoff_swap_rndx_in,
5408   /* Functions to swap out external symbolic data.  */
5409   ecoff_swap_hdr_out,
5410   ecoff_swap_dnr_out,
5411   ecoff_swap_pdr_out,
5412   ecoff_swap_sym_out,
5413   ecoff_swap_opt_out,
5414   ecoff_swap_fdr_out,
5415   ecoff_swap_rfd_out,
5416   ecoff_swap_ext_out,
5417   _bfd_ecoff_swap_tir_out,
5418   _bfd_ecoff_swap_rndx_out,
5419   /* Function to read in symbolic data.  */
5420   elf64_alpha_read_ecoff_info
5421 };
5422 \f
5423 /* Use a non-standard hash bucket size of 8.  */
5424
5425 static const struct elf_size_info alpha_elf_size_info =
5426 {
5427   sizeof (Elf64_External_Ehdr),
5428   sizeof (Elf64_External_Phdr),
5429   sizeof (Elf64_External_Shdr),
5430   sizeof (Elf64_External_Rel),
5431   sizeof (Elf64_External_Rela),
5432   sizeof (Elf64_External_Sym),
5433   sizeof (Elf64_External_Dyn),
5434   sizeof (Elf_External_Note),
5435   8,
5436   1,
5437   64, 3,
5438   ELFCLASS64, EV_CURRENT,
5439   bfd_elf64_write_out_phdrs,
5440   bfd_elf64_write_shdrs_and_ehdr,
5441   bfd_elf64_write_relocs,
5442   bfd_elf64_swap_symbol_in,
5443   bfd_elf64_swap_symbol_out,
5444   bfd_elf64_slurp_reloc_table,
5445   bfd_elf64_slurp_symbol_table,
5446   bfd_elf64_swap_dyn_in,
5447   bfd_elf64_swap_dyn_out,
5448   bfd_elf64_swap_reloc_in,
5449   bfd_elf64_swap_reloc_out,
5450   bfd_elf64_swap_reloca_in,
5451   bfd_elf64_swap_reloca_out
5452 };
5453
5454 #define TARGET_LITTLE_SYM       bfd_elf64_alpha_vec
5455 #define TARGET_LITTLE_NAME      "elf64-alpha"
5456 #define ELF_ARCH                bfd_arch_alpha
5457 #define ELF_MACHINE_CODE        EM_ALPHA
5458 #define ELF_MAXPAGESIZE 0x10000
5459
5460 #define bfd_elf64_bfd_link_hash_table_create \
5461   elf64_alpha_bfd_link_hash_table_create
5462
5463 #define bfd_elf64_bfd_reloc_type_lookup \
5464   elf64_alpha_bfd_reloc_type_lookup
5465 #define elf_info_to_howto \
5466   elf64_alpha_info_to_howto
5467
5468 #define bfd_elf64_mkobject \
5469   elf64_alpha_mkobject
5470 #define elf_backend_object_p \
5471   elf64_alpha_object_p
5472
5473 #define elf_backend_section_from_shdr \
5474   elf64_alpha_section_from_shdr
5475 #define elf_backend_section_flags \
5476   elf64_alpha_section_flags
5477 #define elf_backend_fake_sections \
5478   elf64_alpha_fake_sections
5479
5480 #define bfd_elf64_bfd_is_local_label_name \
5481   elf64_alpha_is_local_label_name
5482 #define bfd_elf64_find_nearest_line \
5483   elf64_alpha_find_nearest_line
5484 #define bfd_elf64_bfd_relax_section \
5485   elf64_alpha_relax_section
5486
5487 #define elf_backend_add_symbol_hook \
5488   elf64_alpha_add_symbol_hook
5489 #define elf_backend_check_relocs \
5490   elf64_alpha_check_relocs
5491 #define elf_backend_create_dynamic_sections \
5492   elf64_alpha_create_dynamic_sections
5493 #define elf_backend_adjust_dynamic_symbol \
5494   elf64_alpha_adjust_dynamic_symbol
5495 #define elf_backend_always_size_sections \
5496   elf64_alpha_always_size_sections
5497 #define elf_backend_size_dynamic_sections \
5498   elf64_alpha_size_dynamic_sections
5499 #define elf_backend_relocate_section \
5500   elf64_alpha_relocate_section
5501 #define elf_backend_finish_dynamic_symbol \
5502   elf64_alpha_finish_dynamic_symbol
5503 #define elf_backend_finish_dynamic_sections \
5504   elf64_alpha_finish_dynamic_sections
5505 #define bfd_elf64_bfd_final_link \
5506   elf64_alpha_final_link
5507 #define elf_backend_reloc_type_class \
5508   elf64_alpha_reloc_type_class
5509
5510 #define elf_backend_ecoff_debug_swap \
5511   &elf64_alpha_ecoff_debug_swap
5512
5513 #define elf_backend_size_info \
5514   alpha_elf_size_info
5515
5516 #define elf_backend_special_sections \
5517   elf64_alpha_special_sections
5518
5519 /* A few constants that determine how the .plt section is set up.  */
5520 #define elf_backend_want_got_plt 0
5521 #define elf_backend_plt_readonly 0
5522 #define elf_backend_want_plt_sym 1
5523 #define elf_backend_got_header_size 0
5524
5525 #include "elf64-target.h"
5526 \f
5527 /* FreeBSD support.  */
5528
5529 #undef TARGET_LITTLE_SYM
5530 #define TARGET_LITTLE_SYM       bfd_elf64_alpha_freebsd_vec
5531 #undef TARGET_LITTLE_NAME
5532 #define TARGET_LITTLE_NAME      "elf64-alpha-freebsd"
5533
5534 /* The kernel recognizes executables as valid only if they carry a
5535    "FreeBSD" label in the ELF header.  So we put this label on all
5536    executables and (for simplicity) also all other object files.  */
5537
5538 static void elf64_alpha_fbsd_post_process_headers
5539   PARAMS ((bfd *, struct bfd_link_info *));
5540
5541 static void
5542 elf64_alpha_fbsd_post_process_headers (abfd, link_info)
5543      bfd * abfd;
5544      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
5545 {
5546   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
5547
5548   i_ehdrp = elf_elfheader (abfd);
5549
5550   /* Put an ABI label supported by FreeBSD >= 4.1.  */
5551   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
5552 #ifdef OLD_FREEBSD_ABI_LABEL
5553   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5554   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5555 #endif
5556 }
5557
5558 #undef elf_backend_post_process_headers
5559 #define elf_backend_post_process_headers \
5560   elf64_alpha_fbsd_post_process_headers
5561
5562 #undef  elf64_bed
5563 #define elf64_bed elf64_alpha_fbsd_bed
5564
5565 #include "elf64-target.h"