bfd/elf64-alpha.c

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