bfd/elf64-alpha.c

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