contrib/binutils-2.14/bfd/elf64-x86-64.c

   1 /* X86-64 specific support for 64-bit ELF
   2    Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka <jh@suse.cz>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26
  27 #include "elf/x86-64.h"
  28
  29 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  30 #define MINUS_ONE (~ (bfd_vma) 0)
  31
  32 /* The relocation "howto" table.  Order of fields:
  33    type, size, bitsize, pc_relative, complain_on_overflow,
  34    special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset.  */
  35 static reloc_howto_type x86_64_elf_howto_table[] =
  36 {
  37   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
  38         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
  39         FALSE),
  40   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  41         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
  42         FALSE),
  43   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  44         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
  45         TRUE),
  46   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  47         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
  48         FALSE),
  49   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  50         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
  51         TRUE),
  52   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  53         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
  54         FALSE),
  55   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  56         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
  57         MINUS_ONE, FALSE),
  58   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  59         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
  60         MINUS_ONE, FALSE),
  61   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  62         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
  63         MINUS_ONE, FALSE),
  64   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  65         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
  66         0xffffffff, TRUE),
  67   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
  68         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
  69         FALSE),
  70   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  71         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
  72         FALSE),
  73   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  74         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
  75   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  76         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
  77   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
  78         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
  79   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
  80         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
  81   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  82         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
  83         MINUS_ONE, FALSE),
  84   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
  86         MINUS_ONE, FALSE),
  87   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
  89         MINUS_ONE, FALSE),
  90   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  91         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
  92         0xffffffff, TRUE),
  93   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  94         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
  95         0xffffffff, TRUE),
  96   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
  98         0xffffffff, FALSE),
  99   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 100         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
 101         0xffffffff, TRUE),
 102   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 103         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
 104         0xffffffff, FALSE),
 105
 106 /* GNU extension to record C++ vtable hierarchy.  */
 107   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 108          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 109
 110 /* GNU extension to record C++ vtable member usage.  */
 111   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 112          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 113          FALSE)
 114 };
 115
 116 /* Map BFD relocs to the x86_64 elf relocs.  */
 117 struct elf_reloc_map
 118 {
 119   bfd_reloc_code_real_type bfd_reloc_val;
 120   unsigned char elf_reloc_val;
 121 };
 122
 123 static const struct elf_reloc_map x86_64_reloc_map[] =
 124 {
 125   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 126   { BFD_RELOC_64,               R_X86_64_64,   },
 127   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 128   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 129   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 130   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 131   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 132   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 133   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 134   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 135   { BFD_RELOC_32,               R_X86_64_32, },
 136   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 137   { BFD_RELOC_16,               R_X86_64_16, },
 138   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 139   { BFD_RELOC_8,                R_X86_64_8, },
 140   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 141   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 142   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 143   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 144   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 145   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 146   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 147   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 148   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 149   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 150   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 151 };
 152
 153 static reloc_howto_type *elf64_x86_64_reloc_type_lookup
 154   PARAMS ((bfd *, bfd_reloc_code_real_type));
 155 static void elf64_x86_64_info_to_howto
 156   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
 157 static bfd_boolean elf64_x86_64_grok_prstatus
 158   PARAMS ((bfd *, Elf_Internal_Note *));
 159 static bfd_boolean elf64_x86_64_grok_psinfo
 160   PARAMS ((bfd *, Elf_Internal_Note *));
 161 static struct bfd_link_hash_table *elf64_x86_64_link_hash_table_create
 162   PARAMS ((bfd *));
 163 static int elf64_x86_64_tls_transition
 164   PARAMS ((struct bfd_link_info *, int, int));
 165 static bfd_boolean elf64_x86_64_mkobject
 166   PARAMS((bfd *));
 167 static bfd_boolean elf64_x86_64_elf_object_p PARAMS ((bfd *abfd));
 168 static bfd_boolean create_got_section
 169   PARAMS((bfd *, struct bfd_link_info *));
 170 static bfd_boolean elf64_x86_64_create_dynamic_sections
 171   PARAMS((bfd *, struct bfd_link_info *));
 172 static void elf64_x86_64_copy_indirect_symbol
 173   PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
 174            struct elf_link_hash_entry *));
 175 static bfd_boolean elf64_x86_64_check_relocs
 176   PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
 177            const Elf_Internal_Rela *));
 178 static asection *elf64_x86_64_gc_mark_hook
 179   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
 180            struct elf_link_hash_entry *, Elf_Internal_Sym *));
 181
 182 static bfd_boolean elf64_x86_64_gc_sweep_hook
 183   PARAMS ((bfd *, struct bfd_link_info *, asection *,
 184            const Elf_Internal_Rela *));
 185
 186 static struct bfd_hash_entry *link_hash_newfunc
 187   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 188 static bfd_boolean elf64_x86_64_adjust_dynamic_symbol
 189   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 190
 191 static bfd_boolean allocate_dynrelocs
 192   PARAMS ((struct elf_link_hash_entry *, PTR));
 193 static bfd_boolean readonly_dynrelocs
 194   PARAMS ((struct elf_link_hash_entry *, PTR));
 195 static bfd_boolean elf64_x86_64_size_dynamic_sections
 196   PARAMS ((bfd *, struct bfd_link_info *));
 197 static bfd_vma dtpoff_base
 198   PARAMS ((struct bfd_link_info *));
 199 static bfd_vma tpoff
 200   PARAMS ((struct bfd_link_info *, bfd_vma));
 201 static bfd_boolean elf64_x86_64_relocate_section
 202   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 203          Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
 204 static bfd_boolean elf64_x86_64_finish_dynamic_symbol
 205   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
 206            Elf_Internal_Sym *sym));
 207 static bfd_boolean elf64_x86_64_finish_dynamic_sections
 208   PARAMS ((bfd *, struct bfd_link_info *));
 209 static enum elf_reloc_type_class elf64_x86_64_reloc_type_class
 210   PARAMS ((const Elf_Internal_Rela *));
 211
 212 /* Given a BFD reloc type, return a HOWTO structure.  */
 213 static reloc_howto_type *
 214 elf64_x86_64_reloc_type_lookup (abfd, code)
 215      bfd *abfd ATTRIBUTE_UNUSED;
 216      bfd_reloc_code_real_type code;
 217 {
 218   unsigned int i;
 219   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 220        i++)
 221     {
 222       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 223         return &x86_64_elf_howto_table[i];
 224     }
 225   return 0;
 226 }
 227
 228 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 229
 230 static void
 231 elf64_x86_64_info_to_howto (abfd, cache_ptr, dst)
 232      bfd *abfd ATTRIBUTE_UNUSED;
 233      arelent *cache_ptr;
 234      Elf_Internal_Rela *dst;
 235 {
 236   unsigned r_type, i;
 237
 238   r_type = ELF64_R_TYPE (dst->r_info);
 239   if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
 240     {
 241       BFD_ASSERT (r_type <= (unsigned int) R_X86_64_TPOFF32);
 242       i = r_type;
 243     }
 244   else
 245     {
 246       BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
 247       i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_TPOFF32 - 1);
 248     }
 249   cache_ptr->howto = &x86_64_elf_howto_table[i];
 250   BFD_ASSERT (r_type == cache_ptr->howto->type);
 251 }
 252 \f
 253 /* Support for core dump NOTE sections.  */
 254 static bfd_boolean
 255 elf64_x86_64_grok_prstatus (abfd, note)
 256      bfd *abfd;
 257      Elf_Internal_Note *note;
 258 {
 259   int offset;
 260   size_t raw_size;
 261
 262   switch (note->descsz)
 263     {
 264       default:
 265         return FALSE;
 266
 267       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 268         /* pr_cursig */
 269         elf_tdata (abfd)->core_signal
 270           = bfd_get_16 (abfd, note->descdata + 12);
 271
 272         /* pr_pid */
 273         elf_tdata (abfd)->core_pid
 274           = bfd_get_32 (abfd, note->descdata + 32);
 275
 276         /* pr_reg */
 277         offset = 112;
 278         raw_size = 216;
 279
 280         break;
 281     }
 282
 283   /* Make a ".reg/999" section.  */
 284   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 285                                           raw_size, note->descpos + offset);
 286 }
 287
 288 static bfd_boolean
 289 elf64_x86_64_grok_psinfo (abfd, note)
 290      bfd *abfd;
 291      Elf_Internal_Note *note;
 292 {
 293   switch (note->descsz)
 294     {
 295       default:
 296         return FALSE;
 297
 298       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 299         elf_tdata (abfd)->core_program
 300          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 301         elf_tdata (abfd)->core_command
 302          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 303     }
 304
 305   /* Note that for some reason, a spurious space is tacked
 306      onto the end of the args in some (at least one anyway)
 307      implementations, so strip it off if it exists.  */
 308
 309   {
 310     char *command = elf_tdata (abfd)->core_command;
 311     int n = strlen (command);
 312
 313     if (0 < n && command[n - 1] == ' ')
 314       command[n - 1] = '\0';
 315   }
 316
 317   return TRUE;
 318 }
 319 \f
 320 /* Functions for the x86-64 ELF linker.  */
 321
 322 /* The name of the dynamic interpreter.  This is put in the .interp
 323    section.  */
 324
 325 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 326
 327 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 328    copying dynamic variables from a shared lib into an app's dynbss
 329    section, and instead use a dynamic relocation to point into the
 330    shared lib.  */
 331 #define ELIMINATE_COPY_RELOCS 1
 332
 333 /* The size in bytes of an entry in the global offset table.  */
 334
 335 #define GOT_ENTRY_SIZE 8
 336
 337 /* The size in bytes of an entry in the procedure linkage table.  */
 338
 339 #define PLT_ENTRY_SIZE 16
 340
 341 /* The first entry in a procedure linkage table looks like this.  See the
 342    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
 343
 344 static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
 345 {
 346   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 347   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 348   0x90, 0x90, 0x90, 0x90        /* pad out to 16 bytes with nops.  */
 349 };
 350
 351 /* Subsequent entries in a procedure linkage table look like this.  */
 352
 353 static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
 354 {
 355   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 356   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 357   0x68,         /* pushq immediate */
 358   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 359   0xe9,         /* jmp relative */
 360   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 361 };
 362
 363 /* The x86-64 linker needs to keep track of the number of relocs that
 364    it decides to copy as dynamic relocs in check_relocs for each symbol.
 365    This is so that it can later discard them if they are found to be
 366    unnecessary.  We store the information in a field extending the
 367    regular ELF linker hash table.  */
 368
 369 struct elf64_x86_64_dyn_relocs
 370 {
 371   /* Next section.  */
 372   struct elf64_x86_64_dyn_relocs *next;
 373
 374   /* The input section of the reloc.  */
 375   asection *sec;
 376
 377   /* Total number of relocs copied for the input section.  */
 378   bfd_size_type count;
 379
 380   /* Number of pc-relative relocs copied for the input section.  */
 381   bfd_size_type pc_count;
 382 };
 383
 384 /* x86-64 ELF linker hash entry.  */
 385
 386 struct elf64_x86_64_link_hash_entry
 387 {
 388   struct elf_link_hash_entry elf;
 389
 390   /* Track dynamic relocs copied for this symbol.  */
 391   struct elf64_x86_64_dyn_relocs *dyn_relocs;
 392
 393 #define GOT_UNKNOWN     0
 394 #define GOT_NORMAL      1
 395 #define GOT_TLS_GD      2
 396 #define GOT_TLS_IE      3
 397   unsigned char tls_type;
 398 };
 399
 400 #define elf64_x86_64_hash_entry(ent) \
 401   ((struct elf64_x86_64_link_hash_entry *)(ent))
 402
 403 struct elf64_x86_64_obj_tdata
 404 {
 405   struct elf_obj_tdata root;
 406
 407   /* tls_type for each local got entry.  */
 408   char *local_got_tls_type;
 409 };
 410
 411 #define elf64_x86_64_tdata(abfd) \
 412   ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
 413
 414 #define elf64_x86_64_local_got_tls_type(abfd) \
 415   (elf64_x86_64_tdata (abfd)->local_got_tls_type)
 416
 417
 418 /* x86-64 ELF linker hash table.  */
 419
 420 struct elf64_x86_64_link_hash_table
 421 {
 422   struct elf_link_hash_table elf;
 423
 424   /* Short-cuts to get to dynamic linker sections.  */
 425   asection *sgot;
 426   asection *sgotplt;
 427   asection *srelgot;
 428   asection *splt;
 429   asection *srelplt;
 430   asection *sdynbss;
 431   asection *srelbss;
 432
 433   union {
 434     bfd_signed_vma refcount;
 435     bfd_vma offset;
 436   } tls_ld_got;
 437
 438   /* Small local sym to section mapping cache.  */
 439   struct sym_sec_cache sym_sec;
 440 };
 441
 442 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
 443
 444 #define elf64_x86_64_hash_table(p) \
 445   ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
 446
 447 /* Create an entry in an x86-64 ELF linker hash table.  */
 448
 449 static struct bfd_hash_entry *
 450 link_hash_newfunc (entry, table, string)
 451      struct bfd_hash_entry *entry;
 452      struct bfd_hash_table *table;
 453      const char *string;
 454 {
 455   /* Allocate the structure if it has not already been allocated by a
 456      subclass.  */
 457   if (entry == NULL)
 458     {
 459       entry = bfd_hash_allocate (table,
 460                                  sizeof (struct elf64_x86_64_link_hash_entry));
 461       if (entry == NULL)
 462         return entry;
 463     }
 464
 465   /* Call the allocation method of the superclass.  */
 466   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 467   if (entry != NULL)
 468     {
 469       struct elf64_x86_64_link_hash_entry *eh;
 470
 471       eh = (struct elf64_x86_64_link_hash_entry *) entry;
 472       eh->dyn_relocs = NULL;
 473       eh->tls_type = GOT_UNKNOWN;
 474     }
 475
 476   return entry;
 477 }
 478
 479 /* Create an X86-64 ELF linker hash table.  */
 480
 481 static struct bfd_link_hash_table *
 482 elf64_x86_64_link_hash_table_create (abfd)
 483      bfd *abfd;
 484 {
 485   struct elf64_x86_64_link_hash_table *ret;
 486   bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
 487
 488   ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
 489   if (ret == NULL)
 490     return NULL;
 491
 492   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 493     {
 494       free (ret);
 495       return NULL;
 496     }
 497
 498   ret->sgot = NULL;
 499   ret->sgotplt = NULL;
 500   ret->srelgot = NULL;
 501   ret->splt = NULL;
 502   ret->srelplt = NULL;
 503   ret->sdynbss = NULL;
 504   ret->srelbss = NULL;
 505   ret->sym_sec.abfd = NULL;
 506   ret->tls_ld_got.refcount = 0;
 507
 508   return &ret->elf.root;
 509 }
 510
 511 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 512    shortcuts to them in our hash table.  */
 513
 514 static bfd_boolean
 515 create_got_section (dynobj, info)
 516      bfd *dynobj;
 517      struct bfd_link_info *info;
 518 {
 519   struct elf64_x86_64_link_hash_table *htab;
 520
 521   if (! _bfd_elf_create_got_section (dynobj, info))
 522     return FALSE;
 523
 524   htab = elf64_x86_64_hash_table (info);
 525   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 526   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 527   if (!htab->sgot || !htab->sgotplt)
 528     abort ();
 529
 530   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
 531   if (htab->srelgot == NULL
 532       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 533                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 534                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 535                                    | SEC_READONLY))
 536       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
 537     return FALSE;
 538   return TRUE;
 539 }
 540
 541 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 542    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 543    hash table.  */
 544
 545 static bfd_boolean
 546 elf64_x86_64_create_dynamic_sections (dynobj, info)
 547      bfd *dynobj;
 548      struct bfd_link_info *info;
 549 {
 550   struct elf64_x86_64_link_hash_table *htab;
 551
 552   htab = elf64_x86_64_hash_table (info);
 553   if (!htab->sgot && !create_got_section (dynobj, info))
 554     return FALSE;
 555
 556   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 557     return FALSE;
 558
 559   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 560   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 561   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 562   if (!info->shared)
 563     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 564
 565   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 566       || (!info->shared && !htab->srelbss))
 567     abort ();
 568
 569   return TRUE;
 570 }
 571
 572 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 573
 574 static void
 575 elf64_x86_64_copy_indirect_symbol (bed, dir, ind)
 576      struct elf_backend_data *bed;
 577      struct elf_link_hash_entry *dir, *ind;
 578 {
 579   struct elf64_x86_64_link_hash_entry *edir, *eind;
 580
 581   edir = (struct elf64_x86_64_link_hash_entry *) dir;
 582   eind = (struct elf64_x86_64_link_hash_entry *) ind;
 583
 584   if (eind->dyn_relocs != NULL)
 585     {
 586       if (edir->dyn_relocs != NULL)
 587         {
 588           struct elf64_x86_64_dyn_relocs **pp;
 589           struct elf64_x86_64_dyn_relocs *p;
 590
 591           if (ind->root.type == bfd_link_hash_indirect)
 592             abort ();
 593
 594           /* Add reloc counts against the weak sym to the strong sym
 595              list.  Merge any entries against the same section.  */
 596           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 597             {
 598               struct elf64_x86_64_dyn_relocs *q;
 599
 600               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 601                 if (q->sec == p->sec)
 602                   {
 603                     q->pc_count += p->pc_count;
 604                     q->count += p->count;
 605                     *pp = p->next;
 606                     break;
 607                   }
 608               if (q == NULL)
 609                 pp = &p->next;
 610             }
 611           *pp = edir->dyn_relocs;
 612         }
 613
 614       edir->dyn_relocs = eind->dyn_relocs;
 615       eind->dyn_relocs = NULL;
 616     }
 617
 618   if (ind->root.type == bfd_link_hash_indirect
 619       && dir->got.refcount <= 0)
 620     {
 621       edir->tls_type = eind->tls_type;
 622       eind->tls_type = GOT_UNKNOWN;
 623     }
 624
 625   if (ELIMINATE_COPY_RELOCS
 626       && ind->root.type != bfd_link_hash_indirect
 627       && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
 628     /* If called to transfer flags for a weakdef during processing
 629        of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
 630        We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 631     dir->elf_link_hash_flags |=
 632       (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
 633                                    | ELF_LINK_HASH_REF_REGULAR
 634                                    | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
 635   else
 636     _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 637 }
 638
 639 static bfd_boolean
 640 elf64_x86_64_mkobject (abfd)
 641      bfd *abfd;
 642 {
 643   bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
 644   abfd->tdata.any = bfd_zalloc (abfd, amt);
 645   if (abfd->tdata.any == NULL)
 646     return FALSE;
 647   return TRUE;
 648 }
 649
 650 static bfd_boolean
 651 elf64_x86_64_elf_object_p (abfd)
 652   bfd *abfd;
 653 {
 654   /* Allocate our special target data.  */
 655   struct elf64_x86_64_obj_tdata *new_tdata;
 656   bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
 657   new_tdata = bfd_zalloc (abfd, amt);
 658   if (new_tdata == NULL)
 659     return FALSE;
 660   new_tdata->root = *abfd->tdata.elf_obj_data;
 661   abfd->tdata.any = new_tdata;
 662   /* Set the right machine number for an x86-64 elf64 file.  */
 663   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
 664   return TRUE;
 665 }
 666
 667 static int
 668 elf64_x86_64_tls_transition (info, r_type, is_local)
 669      struct bfd_link_info *info;
 670      int r_type;
 671      int is_local;
 672 {
 673   if (info->shared)
 674     return r_type;
 675
 676   switch (r_type)
 677     {
 678     case R_X86_64_TLSGD:
 679     case R_X86_64_GOTTPOFF:
 680       if (is_local)
 681         return R_X86_64_TPOFF32;
 682       return R_X86_64_GOTTPOFF;
 683     case R_X86_64_TLSLD:
 684       return R_X86_64_TPOFF32;
 685     }
 686
 687    return r_type;
 688 }
 689
 690 /* Look through the relocs for a section during the first phase, and
 691    calculate needed space in the global offset table, procedure
 692    linkage table, and dynamic reloc sections.  */
 693
 694 static bfd_boolean
 695 elf64_x86_64_check_relocs (abfd, info, sec, relocs)
 696      bfd *abfd;
 697      struct bfd_link_info *info;
 698      asection *sec;
 699      const Elf_Internal_Rela *relocs;
 700 {
 701   struct elf64_x86_64_link_hash_table *htab;
 702   Elf_Internal_Shdr *symtab_hdr;
 703   struct elf_link_hash_entry **sym_hashes;
 704   const Elf_Internal_Rela *rel;
 705   const Elf_Internal_Rela *rel_end;
 706   asection *sreloc;
 707
 708   if (info->relocateable)
 709     return TRUE;
 710
 711   htab = elf64_x86_64_hash_table (info);
 712   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 713   sym_hashes = elf_sym_hashes (abfd);
 714
 715   sreloc = NULL;
 716
 717   rel_end = relocs + sec->reloc_count;
 718   for (rel = relocs; rel < rel_end; rel++)
 719     {
 720       unsigned int r_type;
 721       unsigned long r_symndx;
 722       struct elf_link_hash_entry *h;
 723
 724       r_symndx = ELF64_R_SYM (rel->r_info);
 725       r_type = ELF64_R_TYPE (rel->r_info);
 726
 727       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 728         {
 729           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 730                                  bfd_archive_filename (abfd),
 731                                  r_symndx);
 732           return FALSE;
 733         }
 734
 735       if (r_symndx < symtab_hdr->sh_info)
 736         h = NULL;
 737       else
 738         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 739
 740       r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
 741       switch (r_type)
 742         {
 743         case R_X86_64_TLSLD:
 744           htab->tls_ld_got.refcount += 1;
 745           goto create_got;
 746
 747         case R_X86_64_TPOFF32:
 748           if (info->shared)
 749             {
 750               (*_bfd_error_handler)
 751                 (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
 752                  bfd_archive_filename (abfd),
 753                  x86_64_elf_howto_table[r_type].name);
 754               bfd_set_error (bfd_error_bad_value);
 755               return FALSE;
 756             }
 757           break;
 758
 759         case R_X86_64_GOTTPOFF:
 760           if (info->shared)
 761             info->flags |= DF_STATIC_TLS;
 762           /* Fall through */
 763
 764         case R_X86_64_GOT32:
 765         case R_X86_64_GOTPCREL:
 766         case R_X86_64_TLSGD:
 767           /* This symbol requires a global offset table entry.  */
 768           {
 769             int tls_type, old_tls_type;
 770
 771             switch (r_type)
 772               {
 773               default: tls_type = GOT_NORMAL; break;
 774               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
 775               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
 776               }
 777
 778             if (h != NULL)
 779               {
 780                 h->got.refcount += 1;
 781                 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
 782               }
 783             else
 784               {
 785                 bfd_signed_vma *local_got_refcounts;
 786
 787                 /* This is a global offset table entry for a local symbol.  */
 788                 local_got_refcounts = elf_local_got_refcounts (abfd);
 789                 if (local_got_refcounts == NULL)
 790                   {
 791                     bfd_size_type size;
 792
 793                     size = symtab_hdr->sh_info;
 794                     size *= sizeof (bfd_signed_vma) + sizeof (char);
 795                     local_got_refcounts = ((bfd_signed_vma *)
 796                                            bfd_zalloc (abfd, size));
 797                     if (local_got_refcounts == NULL)
 798                       return FALSE;
 799                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 800                     elf64_x86_64_local_got_tls_type (abfd)
 801                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
 802                   }
 803                 local_got_refcounts[r_symndx] += 1;
 804                 old_tls_type
 805                   = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
 806               }
 807
 808             /* If a TLS symbol is accessed using IE at least once,
 809                there is no point to use dynamic model for it.  */
 810             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
 811                 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
 812               {
 813                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
 814                   tls_type = old_tls_type;
 815                 else
 816                   {
 817                     (*_bfd_error_handler)
 818                       (_("%s: %s' accessed both as normal and thread local symbol"),
 819                        bfd_archive_filename (abfd),
 820                        h ? h->root.root.string : "<local>");
 821                     return FALSE;
 822                   }
 823               }
 824
 825             if (old_tls_type != tls_type)
 826               {
 827                 if (h != NULL)
 828                   elf64_x86_64_hash_entry (h)->tls_type = tls_type;
 829                 else
 830                   elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
 831               }
 832           }
 833           /* Fall through */
 834
 835           //case R_X86_64_GOTPCREL:
 836         create_got:
 837           if (htab->sgot == NULL)
 838             {
 839               if (htab->elf.dynobj == NULL)
 840                 htab->elf.dynobj = abfd;
 841               if (!create_got_section (htab->elf.dynobj, info))
 842                 return FALSE;
 843             }
 844           break;
 845
 846         case R_X86_64_PLT32:
 847           /* This symbol requires a procedure linkage table entry.  We
 848              actually build the entry in adjust_dynamic_symbol,
 849              because this might be a case of linking PIC code which is
 850              never referenced by a dynamic object, in which case we
 851              don't need to generate a procedure linkage table entry
 852              after all.  */
 853
 854           /* If this is a local symbol, we resolve it directly without
 855              creating a procedure linkage table entry.  */
 856           if (h == NULL)
 857             continue;
 858
 859           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 860           h->plt.refcount += 1;
 861           break;
 862
 863         case R_X86_64_8:
 864         case R_X86_64_16:
 865         case R_X86_64_32:
 866         case R_X86_64_32S:
 867           /* Let's help debug shared library creation.  These relocs
 868              cannot be used in shared libs.  Don't error out for
 869              sections we don't care about, such as debug sections or
 870              non-constant sections.  */
 871           if (info->shared
 872               && (sec->flags & SEC_ALLOC) != 0
 873               && (sec->flags & SEC_READONLY) != 0)
 874             {
 875               (*_bfd_error_handler)
 876                 (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
 877                  bfd_archive_filename (abfd),
 878                  x86_64_elf_howto_table[r_type].name);
 879               bfd_set_error (bfd_error_bad_value);
 880               return FALSE;
 881             }
 882           /* Fall through.  */
 883
 884         case R_X86_64_PC8:
 885         case R_X86_64_PC16:
 886         case R_X86_64_PC32:
 887         case R_X86_64_64:
 888           if (h != NULL && !info->shared)
 889             {
 890               /* If this reloc is in a read-only section, we might
 891                  need a copy reloc.  We can't check reliably at this
 892                  stage whether the section is read-only, as input
 893                  sections have not yet been mapped to output sections.
 894                  Tentatively set the flag for now, and correct in
 895                  adjust_dynamic_symbol.  */
 896               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 897
 898               /* We may need a .plt entry if the function this reloc
 899                  refers to is in a shared lib.  */
 900               h->plt.refcount += 1;
 901             }
 902
 903           /* If we are creating a shared library, and this is a reloc
 904              against a global symbol, or a non PC relative reloc
 905              against a local symbol, then we need to copy the reloc
 906              into the shared library.  However, if we are linking with
 907              -Bsymbolic, we do not need to copy a reloc against a
 908              global symbol which is defined in an object we are
 909              including in the link (i.e., DEF_REGULAR is set).  At
 910              this point we have not seen all the input files, so it is
 911              possible that DEF_REGULAR is not set now but will be set
 912              later (it is never cleared).  In case of a weak definition,
 913              DEF_REGULAR may be cleared later by a strong definition in
 914              a shared library.  We account for that possibility below by
 915              storing information in the relocs_copied field of the hash
 916              table entry.  A similar situation occurs when creating
 917              shared libraries and symbol visibility changes render the
 918              symbol local.
 919
 920              If on the other hand, we are creating an executable, we
 921              may need to keep relocations for symbols satisfied by a
 922              dynamic library if we manage to avoid copy relocs for the
 923              symbol.  */
 924           if ((info->shared
 925                && (sec->flags & SEC_ALLOC) != 0
 926                && (((r_type != R_X86_64_PC8)
 927                     && (r_type != R_X86_64_PC16)
 928                     && (r_type != R_X86_64_PC32))
 929                    || (h != NULL
 930                        && (! info->symbolic
 931                            || h->root.type == bfd_link_hash_defweak
 932                            || (h->elf_link_hash_flags
 933                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 934               || (ELIMINATE_COPY_RELOCS
 935                   && !info->shared
 936                   && (sec->flags & SEC_ALLOC) != 0
 937                   && h != NULL
 938                   && (h->root.type == bfd_link_hash_defweak
 939                       || (h->elf_link_hash_flags
 940                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
 941             {
 942               struct elf64_x86_64_dyn_relocs *p;
 943               struct elf64_x86_64_dyn_relocs **head;
 944
 945               /* We must copy these reloc types into the output file.
 946                  Create a reloc section in dynobj and make room for
 947                  this reloc.  */
 948               if (sreloc == NULL)
 949                 {
 950                   const char *name;
 951                   bfd *dynobj;
 952
 953                   name = (bfd_elf_string_from_elf_section
 954                           (abfd,
 955                            elf_elfheader (abfd)->e_shstrndx,
 956                            elf_section_data (sec)->rel_hdr.sh_name));
 957                   if (name == NULL)
 958                     return FALSE;
 959
 960                   if (strncmp (name, ".rela", 5) != 0
 961                       || strcmp (bfd_get_section_name (abfd, sec),
 962                                  name + 5) != 0)
 963                     {
 964                       (*_bfd_error_handler)
 965                         (_("%s: bad relocation section name `%s\'"),
 966                          bfd_archive_filename (abfd), name);
 967                     }
 968
 969                   if (htab->elf.dynobj == NULL)
 970                     htab->elf.dynobj = abfd;
 971
 972                   dynobj = htab->elf.dynobj;
 973
 974                   sreloc = bfd_get_section_by_name (dynobj, name);
 975                   if (sreloc == NULL)
 976                     {
 977                       flagword flags;
 978
 979                       sreloc = bfd_make_section (dynobj, name);
 980                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 981                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 982                       if ((sec->flags & SEC_ALLOC) != 0)
 983                         flags |= SEC_ALLOC | SEC_LOAD;
 984                       if (sreloc == NULL
 985                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 986                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
 987                         return FALSE;
 988                     }
 989                   elf_section_data (sec)->sreloc = sreloc;
 990                 }
 991
 992               /* If this is a global symbol, we count the number of
 993                  relocations we need for this symbol.  */
 994               if (h != NULL)
 995                 {
 996                   head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
 997                 }
 998               else
 999                 {
1000                   /* Track dynamic relocs needed for local syms too.
1001                      We really need local syms available to do this
1002                      easily.  Oh well.  */
1003
1004                   asection *s;
1005                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1006                                                  sec, r_symndx);
1007                   if (s == NULL)
1008                     return FALSE;
1009
1010                   head = ((struct elf64_x86_64_dyn_relocs **)
1011                           &elf_section_data (s)->local_dynrel);
1012                 }
1013
1014               p = *head;
1015               if (p == NULL || p->sec != sec)
1016                 {
1017                   bfd_size_type amt = sizeof *p;
1018                   p = ((struct elf64_x86_64_dyn_relocs *)
1019                        bfd_alloc (htab->elf.dynobj, amt));
1020                   if (p == NULL)
1021                     return FALSE;
1022                   p->next = *head;
1023                   *head = p;
1024                   p->sec = sec;
1025                   p->count = 0;
1026                   p->pc_count = 0;
1027                 }
1028
1029               p->count += 1;
1030               if (r_type == R_X86_64_PC8
1031                   || r_type == R_X86_64_PC16
1032                   || r_type == R_X86_64_PC32)
1033                 p->pc_count += 1;
1034             }
1035           break;
1036
1037           /* This relocation describes the C++ object vtable hierarchy.
1038              Reconstruct it for later use during GC.  */
1039         case R_X86_64_GNU_VTINHERIT:
1040           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1041             return FALSE;
1042           break;
1043
1044           /* This relocation describes which C++ vtable entries are actually
1045              used.  Record for later use during GC.  */
1046         case R_X86_64_GNU_VTENTRY:
1047           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1048             return FALSE;
1049           break;
1050
1051         default:
1052           break;
1053         }
1054     }
1055
1056   return TRUE;
1057 }
1058
1059 /* Return the section that should be marked against GC for a given
1060    relocation.  */
1061
1062 static asection *
1063 elf64_x86_64_gc_mark_hook (sec, info, rel, h, sym)
1064      asection *sec;
1065      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1066      Elf_Internal_Rela *rel;
1067      struct elf_link_hash_entry *h;
1068      Elf_Internal_Sym *sym;
1069 {
1070   if (h != NULL)
1071     {
1072       switch (ELF64_R_TYPE (rel->r_info))
1073         {
1074         case R_X86_64_GNU_VTINHERIT:
1075         case R_X86_64_GNU_VTENTRY:
1076           break;
1077
1078         default:
1079           switch (h->root.type)
1080             {
1081             case bfd_link_hash_defined:
1082             case bfd_link_hash_defweak:
1083               return h->root.u.def.section;
1084
1085             case bfd_link_hash_common:
1086               return h->root.u.c.p->section;
1087
1088             default:
1089               break;
1090             }
1091         }
1092     }
1093   else
1094     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1095
1096   return NULL;
1097 }
1098
1099 /* Update the got entry reference counts for the section being removed.  */
1100
1101 static bfd_boolean
1102 elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
1103      bfd *abfd;
1104      struct bfd_link_info *info;
1105      asection *sec;
1106      const Elf_Internal_Rela *relocs;
1107 {
1108   Elf_Internal_Shdr *symtab_hdr;
1109   struct elf_link_hash_entry **sym_hashes;
1110   bfd_signed_vma *local_got_refcounts;
1111   const Elf_Internal_Rela *rel, *relend;
1112
1113   elf_section_data (sec)->local_dynrel = NULL;
1114
1115   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1116   sym_hashes = elf_sym_hashes (abfd);
1117   local_got_refcounts = elf_local_got_refcounts (abfd);
1118
1119   relend = relocs + sec->reloc_count;
1120   for (rel = relocs; rel < relend; rel++)
1121     {
1122       unsigned long r_symndx;
1123       unsigned int r_type;
1124       struct elf_link_hash_entry *h = NULL;
1125
1126       r_symndx = ELF64_R_SYM (rel->r_info);
1127       if (r_symndx >= symtab_hdr->sh_info)
1128         {
1129           struct elf64_x86_64_link_hash_entry *eh;
1130           struct elf64_x86_64_dyn_relocs **pp;
1131           struct elf64_x86_64_dyn_relocs *p;
1132
1133           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1134           eh = (struct elf64_x86_64_link_hash_entry *) h;
1135
1136           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1137             if (p->sec == sec)
1138               {
1139                 /* Everything must go for SEC.  */
1140                 *pp = p->next;
1141                 break;
1142               }
1143         }
1144
1145       r_type = ELF64_R_TYPE (rel->r_info);
1146       r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL);
1147       switch (r_type)
1148         {
1149         case R_X86_64_TLSLD:
1150           if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
1151             elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
1152           break;
1153
1154         case R_X86_64_TLSGD:
1155         case R_X86_64_GOTTPOFF:
1156         case R_X86_64_GOT32:
1157         case R_X86_64_GOTPCREL:
1158           if (h != NULL)
1159             {
1160               if (h->got.refcount > 0)
1161                 h->got.refcount -= 1;
1162             }
1163           else if (local_got_refcounts != NULL)
1164             {
1165               if (local_got_refcounts[r_symndx] > 0)
1166                 local_got_refcounts[r_symndx] -= 1;
1167             }
1168           break;
1169
1170         case R_X86_64_8:
1171         case R_X86_64_16:
1172         case R_X86_64_32:
1173         case R_X86_64_64:
1174         case R_X86_64_32S:
1175         case R_X86_64_PC8:
1176         case R_X86_64_PC16:
1177         case R_X86_64_PC32:
1178           if (info->shared)
1179             break;
1180           /* Fall thru */
1181
1182         case R_X86_64_PLT32:
1183           if (h != NULL)
1184             {
1185               if (h->plt.refcount > 0)
1186                 h->plt.refcount -= 1;
1187             }
1188           break;
1189
1190         default:
1191           break;
1192         }
1193     }
1194
1195   return TRUE;
1196 }
1197
1198 /* Adjust a symbol defined by a dynamic object and referenced by a
1199    regular object.  The current definition is in some section of the
1200    dynamic object, but we're not including those sections.  We have to
1201    change the definition to something the rest of the link can
1202    understand.  */
1203
1204 static bfd_boolean
1205 elf64_x86_64_adjust_dynamic_symbol (info, h)
1206      struct bfd_link_info *info;
1207      struct elf_link_hash_entry *h;
1208 {
1209   struct elf64_x86_64_link_hash_table *htab;
1210   asection *s;
1211   unsigned int power_of_two;
1212
1213   /* If this is a function, put it in the procedure linkage table.  We
1214      will fill in the contents of the procedure linkage table later,
1215      when we know the address of the .got section.  */
1216   if (h->type == STT_FUNC
1217       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1218     {
1219       if (h->plt.refcount <= 0
1220           || (! info->shared
1221               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1222               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1223               && h->root.type != bfd_link_hash_undefweak
1224               && h->root.type != bfd_link_hash_undefined))
1225         {
1226           /* This case can occur if we saw a PLT32 reloc in an input
1227              file, but the symbol was never referred to by a dynamic
1228              object, or if all references were garbage collected.  In
1229              such a case, we don't actually need to build a procedure
1230              linkage table, and we can just do a PC32 reloc instead.  */
1231           h->plt.offset = (bfd_vma) -1;
1232           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1233         }
1234
1235       return TRUE;
1236     }
1237   else
1238     /* It's possible that we incorrectly decided a .plt reloc was
1239        needed for an R_X86_64_PC32 reloc to a non-function sym in
1240        check_relocs.  We can't decide accurately between function and
1241        non-function syms in check-relocs;  Objects loaded later in
1242        the link may change h->type.  So fix it now.  */
1243     h->plt.offset = (bfd_vma) -1;
1244
1245   /* If this is a weak symbol, and there is a real definition, the
1246      processor independent code will have arranged for us to see the
1247      real definition first, and we can just use the same value.  */
1248   if (h->weakdef != NULL)
1249     {
1250       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1251                   || h->weakdef->root.type == bfd_link_hash_defweak);
1252       h->root.u.def.section = h->weakdef->root.u.def.section;
1253       h->root.u.def.value = h->weakdef->root.u.def.value;
1254       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1255         h->elf_link_hash_flags
1256           = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
1257              | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
1258       return TRUE;
1259     }
1260
1261   /* This is a reference to a symbol defined by a dynamic object which
1262      is not a function.  */
1263
1264   /* If we are creating a shared library, we must presume that the
1265      only references to the symbol are via the global offset table.
1266      For such cases we need not do anything here; the relocations will
1267      be handled correctly by relocate_section.  */
1268   if (info->shared)
1269     return TRUE;
1270
1271   /* If there are no references to this symbol that do not use the
1272      GOT, we don't need to generate a copy reloc.  */
1273   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1274     return TRUE;
1275
1276   /* If -z nocopyreloc was given, we won't generate them either.  */
1277   if (info->nocopyreloc)
1278     {
1279       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1280       return TRUE;
1281     }
1282
1283   if (ELIMINATE_COPY_RELOCS)
1284     {
1285       struct elf64_x86_64_link_hash_entry * eh;
1286       struct elf64_x86_64_dyn_relocs *p;
1287
1288       eh = (struct elf64_x86_64_link_hash_entry *) h;
1289       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1290         {
1291           s = p->sec->output_section;
1292           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1293             break;
1294         }
1295
1296       /* If we didn't find any dynamic relocs in read-only sections, then
1297          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1298       if (p == NULL)
1299         {
1300           h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1301           return TRUE;
1302         }
1303     }
1304
1305   /* We must allocate the symbol in our .dynbss section, which will
1306      become part of the .bss section of the executable.  There will be
1307      an entry for this symbol in the .dynsym section.  The dynamic
1308      object will contain position independent code, so all references
1309      from the dynamic object to this symbol will go through the global
1310      offset table.  The dynamic linker will use the .dynsym entry to
1311      determine the address it must put in the global offset table, so
1312      both the dynamic object and the regular object will refer to the
1313      same memory location for the variable.  */
1314
1315   htab = elf64_x86_64_hash_table (info);
1316
1317   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1318      to copy the initial value out of the dynamic object and into the
1319      runtime process image.  */
1320   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1321     {
1322       htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
1323       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1324     }
1325
1326   /* We need to figure out the alignment required for this symbol.  I
1327      have no idea how ELF linkers handle this.  16-bytes is the size
1328      of the largest type that requires hard alignment -- long double.  */
1329   /* FIXME: This is VERY ugly. Should be fixed for all architectures using
1330      this construct.  */
1331   power_of_two = bfd_log2 (h->size);
1332   if (power_of_two > 4)
1333     power_of_two = 4;
1334
1335   /* Apply the required alignment.  */
1336   s = htab->sdynbss;
1337   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1338   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1339     {
1340       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1341         return FALSE;
1342     }
1343
1344   /* Define the symbol as being at this point in the section.  */
1345   h->root.u.def.section = s;
1346   h->root.u.def.value = s->_raw_size;
1347
1348   /* Increment the section size to make room for the symbol.  */
1349   s->_raw_size += h->size;
1350
1351   return TRUE;
1352 }
1353
1354 /* This is the condition under which elf64_x86_64_finish_dynamic_symbol
1355    will be called from elflink.h.  If elflink.h doesn't call our
1356    finish_dynamic_symbol routine, we'll need to do something about
1357    initializing any .plt and .got entries in elf64_x86_64_relocate_section.  */
1358 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1359   ((DYN)                                                                \
1360    && ((INFO)->shared                                                   \
1361        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1362    && ((H)->dynindx != -1                                               \
1363        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1364
1365 /* Allocate space in .plt, .got and associated reloc sections for
1366    dynamic relocs.  */
1367
1368 static bfd_boolean
1369 allocate_dynrelocs (h, inf)
1370      struct elf_link_hash_entry *h;
1371      PTR inf;
1372 {
1373   struct bfd_link_info *info;
1374   struct elf64_x86_64_link_hash_table *htab;
1375   struct elf64_x86_64_link_hash_entry *eh;
1376   struct elf64_x86_64_dyn_relocs *p;
1377
1378   if (h->root.type == bfd_link_hash_indirect)
1379     return TRUE;
1380
1381   if (h->root.type == bfd_link_hash_warning)
1382     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1383
1384   info = (struct bfd_link_info *) inf;
1385   htab = elf64_x86_64_hash_table (info);
1386
1387   if (htab->elf.dynamic_sections_created
1388       && h->plt.refcount > 0)
1389     {
1390       /* Make sure this symbol is output as a dynamic symbol.
1391          Undefined weak syms won't yet be marked as dynamic.  */
1392       if (h->dynindx == -1
1393           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1394         {
1395           if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1396             return FALSE;
1397         }
1398
1399       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1400         {
1401           asection *s = htab->splt;
1402
1403           /* If this is the first .plt entry, make room for the special
1404              first entry.  */
1405           if (s->_raw_size == 0)
1406             s->_raw_size += PLT_ENTRY_SIZE;
1407
1408           h->plt.offset = s->_raw_size;
1409
1410           /* If this symbol is not defined in a regular file, and we are
1411              not generating a shared library, then set the symbol to this
1412              location in the .plt.  This is required to make function
1413              pointers compare as equal between the normal executable and
1414              the shared library.  */
1415           if (! info->shared
1416               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1417             {
1418               h->root.u.def.section = s;
1419               h->root.u.def.value = h->plt.offset;
1420             }
1421
1422           /* Make room for this entry.  */
1423           s->_raw_size += PLT_ENTRY_SIZE;
1424
1425           /* We also need to make an entry in the .got.plt section, which
1426              will be placed in the .got section by the linker script.  */
1427           htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
1428
1429           /* We also need to make an entry in the .rela.plt section.  */
1430           htab->srelplt->_raw_size += sizeof (Elf64_External_Rela);
1431         }
1432       else
1433         {
1434           h->plt.offset = (bfd_vma) -1;
1435           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1436         }
1437     }
1438   else
1439     {
1440       h->plt.offset = (bfd_vma) -1;
1441       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1442     }
1443
1444   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1445      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
1446   if (h->got.refcount > 0
1447       && !info->shared
1448       && h->dynindx == -1
1449       && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
1450     h->got.offset = (bfd_vma) -1;
1451   else if (h->got.refcount > 0)
1452     {
1453       asection *s;
1454       bfd_boolean dyn;
1455       int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
1456
1457       /* Make sure this symbol is output as a dynamic symbol.
1458          Undefined weak syms won't yet be marked as dynamic.  */
1459       if (h->dynindx == -1
1460           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1461         {
1462           if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1463             return FALSE;
1464         }
1465
1466       s = htab->sgot;
1467       h->got.offset = s->_raw_size;
1468       s->_raw_size += GOT_ENTRY_SIZE;
1469       /* R_X86_64_TLSGD needs 2 consecutive GOT slots.  */
1470       if (tls_type == GOT_TLS_GD)
1471         s->_raw_size += GOT_ENTRY_SIZE;
1472       dyn = htab->elf.dynamic_sections_created;
1473       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1474          and two if global.
1475          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
1476       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1477           || tls_type == GOT_TLS_IE)
1478         htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1479       else if (tls_type == GOT_TLS_GD)
1480         htab->srelgot->_raw_size += 2 * sizeof (Elf64_External_Rela);
1481       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1482         htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1483     }
1484   else
1485     h->got.offset = (bfd_vma) -1;
1486
1487   eh = (struct elf64_x86_64_link_hash_entry *) h;
1488   if (eh->dyn_relocs == NULL)
1489     return TRUE;
1490
1491   /* In the shared -Bsymbolic case, discard space allocated for
1492      dynamic pc-relative relocs against symbols which turn out to be
1493      defined in regular objects.  For the normal shared case, discard
1494      space for pc-relative relocs that have become local due to symbol
1495      visibility changes.  */
1496
1497   if (info->shared)
1498     {
1499       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1500           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1501               || info->symbolic))
1502         {
1503           struct elf64_x86_64_dyn_relocs **pp;
1504
1505           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1506             {
1507               p->count -= p->pc_count;
1508               p->pc_count = 0;
1509               if (p->count == 0)
1510                 *pp = p->next;
1511               else
1512                 pp = &p->next;
1513             }
1514         }
1515     }
1516   else if (ELIMINATE_COPY_RELOCS)
1517     {
1518       /* For the non-shared case, discard space for relocs against
1519          symbols which turn out to need copy relocs or are not
1520          dynamic.  */
1521
1522       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1523           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1524                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1525               || (htab->elf.dynamic_sections_created
1526                   && (h->root.type == bfd_link_hash_undefweak
1527                       || h->root.type == bfd_link_hash_undefined))))
1528         {
1529           /* Make sure this symbol is output as a dynamic symbol.
1530              Undefined weak syms won't yet be marked as dynamic.  */
1531           if (h->dynindx == -1
1532               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1533             {
1534               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1535                 return FALSE;
1536             }
1537
1538           /* If that succeeded, we know we'll be keeping all the
1539              relocs.  */
1540           if (h->dynindx != -1)
1541             goto keep;
1542         }
1543
1544       eh->dyn_relocs = NULL;
1545
1546     keep: ;
1547     }
1548
1549   /* Finally, allocate space.  */
1550   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1551     {
1552       asection *sreloc = elf_section_data (p->sec)->sreloc;
1553       sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
1554     }
1555
1556   return TRUE;
1557 }
1558
1559 /* Find any dynamic relocs that apply to read-only sections.  */
1560
1561 static bfd_boolean
1562 readonly_dynrelocs (h, inf)
1563      struct elf_link_hash_entry *h;
1564      PTR inf;
1565 {
1566   struct elf64_x86_64_link_hash_entry *eh;
1567   struct elf64_x86_64_dyn_relocs *p;
1568
1569   if (h->root.type == bfd_link_hash_warning)
1570     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1571
1572   eh = (struct elf64_x86_64_link_hash_entry *) h;
1573   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1574     {
1575       asection *s = p->sec->output_section;
1576
1577       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1578         {
1579           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1580
1581           info->flags |= DF_TEXTREL;
1582
1583           /* Not an error, just cut short the traversal.  */
1584           return FALSE;
1585         }
1586     }
1587   return TRUE;
1588 }
1589
1590 /* Set the sizes of the dynamic sections.  */
1591
1592 static bfd_boolean
1593 elf64_x86_64_size_dynamic_sections (output_bfd, info)
1594      bfd *output_bfd ATTRIBUTE_UNUSED;
1595      struct bfd_link_info *info;
1596 {
1597   struct elf64_x86_64_link_hash_table *htab;
1598   bfd *dynobj;
1599   asection *s;
1600   bfd_boolean relocs;
1601   bfd *ibfd;
1602
1603   htab = elf64_x86_64_hash_table (info);
1604   dynobj = htab->elf.dynobj;
1605   if (dynobj == NULL)
1606     abort ();
1607
1608   if (htab->elf.dynamic_sections_created)
1609     {
1610       /* Set the contents of the .interp section to the interpreter.  */
1611       if (! info->shared)
1612         {
1613           s = bfd_get_section_by_name (dynobj, ".interp");
1614           if (s == NULL)
1615             abort ();
1616           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1617           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1618         }
1619     }
1620
1621   /* Set up .got offsets for local syms, and space for local dynamic
1622      relocs.  */
1623   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1624     {
1625       bfd_signed_vma *local_got;
1626       bfd_signed_vma *end_local_got;
1627       char *local_tls_type;
1628       bfd_size_type locsymcount;
1629       Elf_Internal_Shdr *symtab_hdr;
1630       asection *srel;
1631
1632       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1633         continue;
1634
1635       for (s = ibfd->sections; s != NULL; s = s->next)
1636         {
1637           struct elf64_x86_64_dyn_relocs *p;
1638
1639           for (p = *((struct elf64_x86_64_dyn_relocs **)
1640                      &elf_section_data (s)->local_dynrel);
1641                p != NULL;
1642                p = p->next)
1643             {
1644               if (!bfd_is_abs_section (p->sec)
1645                   && bfd_is_abs_section (p->sec->output_section))
1646                 {
1647                   /* Input section has been discarded, either because
1648                      it is a copy of a linkonce section or due to
1649                      linker script /DISCARD/, so we'll be discarding
1650                      the relocs too.  */
1651                 }
1652               else if (p->count != 0)
1653                 {
1654                   srel = elf_section_data (p->sec)->sreloc;
1655                   srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
1656                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1657                     info->flags |= DF_TEXTREL;
1658
1659                 }
1660             }
1661         }
1662
1663       local_got = elf_local_got_refcounts (ibfd);
1664       if (!local_got)
1665         continue;
1666
1667       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1668       locsymcount = symtab_hdr->sh_info;
1669       end_local_got = local_got + locsymcount;
1670       local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
1671       s = htab->sgot;
1672       srel = htab->srelgot;
1673       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1674         {
1675           if (*local_got > 0)
1676             {
1677               *local_got = s->_raw_size;
1678               s->_raw_size += GOT_ENTRY_SIZE;
1679               if (*local_tls_type == GOT_TLS_GD)
1680                 s->_raw_size += GOT_ENTRY_SIZE;
1681               if (info->shared
1682                   || *local_tls_type == GOT_TLS_GD
1683                   || *local_tls_type == GOT_TLS_IE)
1684                 srel->_raw_size += sizeof (Elf64_External_Rela);
1685             }
1686           else
1687             *local_got = (bfd_vma) -1;
1688         }
1689     }
1690
1691   if (htab->tls_ld_got.refcount > 0)
1692     {
1693       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1694          relocs.  */
1695       htab->tls_ld_got.offset = htab->sgot->_raw_size;
1696       htab->sgot->_raw_size += 2 * GOT_ENTRY_SIZE;
1697       htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1698     }
1699   else
1700     htab->tls_ld_got.offset = -1;
1701
1702   /* Allocate global sym .plt and .got entries, and space for global
1703      sym dynamic relocs.  */
1704   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1705
1706   /* We now have determined the sizes of the various dynamic sections.
1707      Allocate memory for them.  */
1708   relocs = FALSE;
1709   for (s = dynobj->sections; s != NULL; s = s->next)
1710     {
1711       if ((s->flags & SEC_LINKER_CREATED) == 0)
1712         continue;
1713
1714       if (s == htab->splt
1715           || s == htab->sgot
1716           || s == htab->sgotplt)
1717         {
1718           /* Strip this section if we don't need it; see the
1719              comment below.  */
1720         }
1721       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1722         {
1723           if (s->_raw_size != 0 && s != htab->srelplt)
1724             relocs = TRUE;
1725
1726           /* We use the reloc_count field as a counter if we need
1727              to copy relocs into the output file.  */
1728           s->reloc_count = 0;
1729         }
1730       else
1731         {
1732           /* It's not one of our sections, so don't allocate space.  */
1733           continue;
1734         }
1735
1736       if (s->_raw_size == 0)
1737         {
1738           /* If we don't need this section, strip it from the
1739              output file.  This is mostly to handle .rela.bss and
1740              .rela.plt.  We must create both sections in
1741              create_dynamic_sections, because they must be created
1742              before the linker maps input sections to output
1743              sections.  The linker does that before
1744              adjust_dynamic_symbol is called, and it is that
1745              function which decides whether anything needs to go
1746              into these sections.  */
1747
1748           _bfd_strip_section_from_output (info, s);
1749           continue;
1750         }
1751
1752       /* Allocate memory for the section contents.  We use bfd_zalloc
1753          here in case unused entries are not reclaimed before the
1754          section's contents are written out.  This should not happen,
1755          but this way if it does, we get a R_X86_64_NONE reloc instead
1756          of garbage.  */
1757       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1758       if (s->contents == NULL)
1759         return FALSE;
1760     }
1761
1762   if (htab->elf.dynamic_sections_created)
1763     {
1764       /* Add some entries to the .dynamic section.  We fill in the
1765          values later, in elf64_x86_64_finish_dynamic_sections, but we
1766          must add the entries now so that we get the correct size for
1767          the .dynamic section.  The DT_DEBUG entry is filled in by the
1768          dynamic linker and used by the debugger.  */
1769 #define add_dynamic_entry(TAG, VAL) \
1770   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1771
1772       if (! info->shared)
1773         {
1774           if (!add_dynamic_entry (DT_DEBUG, 0))
1775             return FALSE;
1776         }
1777
1778       if (htab->splt->_raw_size != 0)
1779         {
1780           if (!add_dynamic_entry (DT_PLTGOT, 0)
1781               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1782               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1783               || !add_dynamic_entry (DT_JMPREL, 0))
1784             return FALSE;
1785         }
1786
1787       if (relocs)
1788         {
1789           if (!add_dynamic_entry (DT_RELA, 0)
1790               || !add_dynamic_entry (DT_RELASZ, 0)
1791               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1792             return FALSE;
1793
1794           /* If any dynamic relocs apply to a read-only section,
1795              then we need a DT_TEXTREL entry.  */
1796           if ((info->flags & DF_TEXTREL) == 0)
1797             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1798                                     (PTR) info);
1799
1800           if ((info->flags & DF_TEXTREL) != 0)
1801             {
1802               if (!add_dynamic_entry (DT_TEXTREL, 0))
1803                 return FALSE;
1804             }
1805         }
1806     }
1807 #undef add_dynamic_entry
1808
1809   return TRUE;
1810 }
1811
1812 /* Return the base VMA address which should be subtracted from real addresses
1813    when resolving @dtpoff relocation.
1814    This is PT_TLS segment p_vaddr.  */
1815
1816 static bfd_vma
1817 dtpoff_base (info)
1818      struct bfd_link_info *info;
1819 {
1820   /* If tls_segment is NULL, we should have signalled an error already.  */
1821   if (elf_hash_table (info)->tls_segment == NULL)
1822     return 0;
1823   return elf_hash_table (info)->tls_segment->start;
1824 }
1825
1826 /* Return the relocation value for @tpoff relocation
1827    if STT_TLS virtual address is ADDRESS.  */
1828
1829 static bfd_vma
1830 tpoff (info, address)
1831      struct bfd_link_info *info;
1832      bfd_vma address;
1833 {
1834   struct elf_link_tls_segment *tls_segment
1835     = elf_hash_table (info)->tls_segment;
1836
1837   /* If tls_segment is NULL, we should have signalled an error already.  */
1838   if (tls_segment == NULL)
1839     return 0;
1840   return address - align_power (tls_segment->size, tls_segment->align)
1841          - tls_segment->start;
1842 }
1843
1844 /* Relocate an x86_64 ELF section.  */
1845
1846 static bfd_boolean
1847 elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
1848                                contents, relocs, local_syms, local_sections)
1849      bfd *output_bfd;
1850      struct bfd_link_info *info;
1851      bfd *input_bfd;
1852      asection *input_section;
1853      bfd_byte *contents;
1854      Elf_Internal_Rela *relocs;
1855      Elf_Internal_Sym *local_syms;
1856      asection **local_sections;
1857 {
1858   struct elf64_x86_64_link_hash_table *htab;
1859   Elf_Internal_Shdr *symtab_hdr;
1860   struct elf_link_hash_entry **sym_hashes;
1861   bfd_vma *local_got_offsets;
1862   Elf_Internal_Rela *rel;
1863   Elf_Internal_Rela *relend;
1864
1865   if (info->relocateable)
1866     return TRUE;
1867
1868   htab = elf64_x86_64_hash_table (info);
1869   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1870   sym_hashes = elf_sym_hashes (input_bfd);
1871   local_got_offsets = elf_local_got_offsets (input_bfd);
1872
1873   rel = relocs;
1874   relend = relocs + input_section->reloc_count;
1875   for (; rel < relend; rel++)
1876     {
1877       unsigned int r_type;
1878       reloc_howto_type *howto;
1879       unsigned long r_symndx;
1880       struct elf_link_hash_entry *h;
1881       Elf_Internal_Sym *sym;
1882       asection *sec;
1883       bfd_vma off;
1884       bfd_vma relocation;
1885       bfd_boolean unresolved_reloc;
1886       bfd_reloc_status_type r;
1887       int tls_type;
1888
1889       r_type = ELF64_R_TYPE (rel->r_info);
1890       if (r_type == (int) R_X86_64_GNU_VTINHERIT
1891           || r_type == (int) R_X86_64_GNU_VTENTRY)
1892         continue;
1893
1894       if (r_type >= R_X86_64_max)
1895         {
1896           bfd_set_error (bfd_error_bad_value);
1897           return FALSE;
1898         }
1899
1900       howto = x86_64_elf_howto_table + r_type;
1901       r_symndx = ELF64_R_SYM (rel->r_info);
1902       h = NULL;
1903       sym = NULL;
1904       sec = NULL;
1905       unresolved_reloc = FALSE;
1906       if (r_symndx < symtab_hdr->sh_info)
1907         {
1908           sym = local_syms + r_symndx;
1909           sec = local_sections[r_symndx];
1910
1911           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1912         }
1913       else
1914         {
1915           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1916           while (h->root.type == bfd_link_hash_indirect
1917                  || h->root.type == bfd_link_hash_warning)
1918             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1919
1920           if (h->root.type == bfd_link_hash_defined
1921               || h->root.type == bfd_link_hash_defweak)
1922             {
1923               sec = h->root.u.def.section;
1924               if (sec->output_section == NULL)
1925                 {
1926                   /* Set a flag that will be cleared later if we find a
1927                      relocation value for this symbol.  output_section
1928                      is typically NULL for symbols satisfied by a shared
1929                      library.  */
1930                   unresolved_reloc = TRUE;
1931                   relocation = 0;
1932                 }
1933               else
1934                 relocation = (h->root.u.def.value
1935                               + sec->output_section->vma
1936                               + sec->output_offset);
1937             }
1938           else if (h->root.type == bfd_link_hash_undefweak)
1939             relocation = 0;
1940           else if (info->shared
1941                    && !info->no_undefined
1942                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1943             relocation = 0;
1944           else
1945             {
1946               if (! ((*info->callbacks->undefined_symbol)
1947                      (info, h->root.root.string, input_bfd,
1948                       input_section, rel->r_offset,
1949                       (!info->shared || info->no_undefined
1950                        || ELF_ST_VISIBILITY (h->other)))))
1951                 return FALSE;
1952               relocation = 0;
1953             }
1954         }
1955       /* When generating a shared object, the relocations handled here are
1956          copied into the output file to be resolved at run time.  */
1957       switch (r_type)
1958         {
1959         case R_X86_64_GOT32:
1960           /* Relocation is to the entry for this symbol in the global
1961              offset table.  */
1962         case R_X86_64_GOTPCREL:
1963           /* Use global offset table as symbol value.  */
1964           if (htab->sgot == NULL)
1965             abort ();
1966
1967           if (h != NULL)
1968             {
1969               bfd_boolean dyn;
1970
1971               off = h->got.offset;
1972               dyn = htab->elf.dynamic_sections_created;
1973
1974               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1975                   || (info->shared
1976                       && (info->symbolic
1977                           || h->dynindx == -1
1978                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1979                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1980                 {
1981                   /* This is actually a static link, or it is a -Bsymbolic
1982                      link and the symbol is defined locally, or the symbol
1983                      was forced to be local because of a version file.  We
1984                      must initialize this entry in the global offset table.
1985                      Since the offset must always be a multiple of 8, we
1986                      use the least significant bit to record whether we
1987                      have initialized it already.
1988
1989                      When doing a dynamic link, we create a .rela.got
1990                      relocation entry to initialize the value.  This is
1991                      done in the finish_dynamic_symbol routine.  */
1992                   if ((off & 1) != 0)
1993                     off &= ~1;
1994                   else
1995                     {
1996                       bfd_put_64 (output_bfd, relocation,
1997                                   htab->sgot->contents + off);
1998                       h->got.offset |= 1;
1999                     }
2000                 }
2001               else
2002                 unresolved_reloc = FALSE;
2003             }
2004           else
2005             {
2006               if (local_got_offsets == NULL)
2007                 abort ();
2008
2009               off = local_got_offsets[r_symndx];
2010
2011               /* The offset must always be a multiple of 8.  We use
2012                  the least significant bit to record whether we have
2013                  already generated the necessary reloc.  */
2014               if ((off & 1) != 0)
2015                 off &= ~1;
2016               else
2017                 {
2018                   bfd_put_64 (output_bfd, relocation,
2019                               htab->sgot->contents + off);
2020
2021                   if (info->shared)
2022                     {
2023                       asection *s;
2024                       Elf_Internal_Rela outrel;
2025                       bfd_byte *loc;
2026
2027                       /* We need to generate a R_X86_64_RELATIVE reloc
2028                          for the dynamic linker.  */
2029                       s = htab->srelgot;
2030                       if (s == NULL)
2031                         abort ();
2032
2033                       outrel.r_offset = (htab->sgot->output_section->vma
2034                                          + htab->sgot->output_offset
2035                                          + off);
2036                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2037                       outrel.r_addend = relocation;
2038                       loc = s->contents;
2039                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2040                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2041                     }
2042
2043                   local_got_offsets[r_symndx] |= 1;
2044                 }
2045             }
2046
2047           if (off >= (bfd_vma) -2)
2048             abort ();
2049
2050           relocation = htab->sgot->output_offset + off;
2051           if (r_type == R_X86_64_GOTPCREL)
2052             relocation += htab->sgot->output_section->vma;
2053
2054           break;
2055
2056         case R_X86_64_PLT32:
2057           /* Relocation is to the entry for this symbol in the
2058              procedure linkage table.  */
2059
2060           /* Resolve a PLT32 reloc against a local symbol directly,
2061              without using the procedure linkage table.  */
2062           if (h == NULL)
2063             break;
2064
2065           if (h->plt.offset == (bfd_vma) -1
2066               || htab->splt == NULL)
2067             {
2068               /* We didn't make a PLT entry for this symbol.  This
2069                  happens when statically linking PIC code, or when
2070                  using -Bsymbolic.  */
2071               break;
2072             }
2073
2074           relocation = (htab->splt->output_section->vma
2075                         + htab->splt->output_offset
2076                         + h->plt.offset);
2077           unresolved_reloc = FALSE;
2078           break;
2079
2080         case R_X86_64_PC8:
2081         case R_X86_64_PC16:
2082         case R_X86_64_PC32:
2083         case R_X86_64_8:
2084         case R_X86_64_16:
2085         case R_X86_64_32:
2086         case R_X86_64_64:
2087           /* FIXME: The ABI says the linker should make sure the value is
2088              the same when it's zeroextended to 64 bit.  */
2089
2090           /* r_symndx will be zero only for relocs against symbols
2091              from removed linkonce sections, or sections discarded by
2092              a linker script.  */
2093           if (r_symndx == 0
2094               || (input_section->flags & SEC_ALLOC) == 0)
2095             break;
2096
2097           if ((info->shared
2098                && ((r_type != R_X86_64_PC8
2099                     && r_type != R_X86_64_PC16
2100                     && r_type != R_X86_64_PC32)
2101                    || (h != NULL
2102                        && h->dynindx != -1
2103                        && (! info->symbolic
2104                            || (h->elf_link_hash_flags
2105                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2106               || (ELIMINATE_COPY_RELOCS
2107                   && !info->shared
2108                   && h != NULL
2109                   && h->dynindx != -1
2110                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2111                   && (((h->elf_link_hash_flags
2112                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2113                        && (h->elf_link_hash_flags
2114                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
2115                       || h->root.type == bfd_link_hash_undefweak
2116                       || h->root.type == bfd_link_hash_undefined)))
2117             {
2118               Elf_Internal_Rela outrel;
2119               bfd_byte *loc;
2120               bfd_boolean skip, relocate;
2121               asection *sreloc;
2122
2123               /* When generating a shared object, these relocations
2124                  are copied into the output file to be resolved at run
2125                  time.  */
2126               skip = FALSE;
2127               relocate = FALSE;
2128
2129               outrel.r_offset =
2130                 _bfd_elf_section_offset (output_bfd, info, input_section,
2131                                          rel->r_offset);
2132               if (outrel.r_offset == (bfd_vma) -1)
2133                 skip = TRUE;
2134               else if (outrel.r_offset == (bfd_vma) -2)
2135                 skip = TRUE, relocate = TRUE;
2136
2137               outrel.r_offset += (input_section->output_section->vma
2138                                   + input_section->output_offset);
2139
2140               if (skip)
2141                 memset (&outrel, 0, sizeof outrel);
2142
2143               /* h->dynindx may be -1 if this symbol was marked to
2144                  become local.  */
2145               else if (h != NULL
2146                        && h->dynindx != -1
2147                        && (r_type == R_X86_64_PC8
2148                            || r_type == R_X86_64_PC16
2149                            || r_type == R_X86_64_PC32
2150                            || !info->shared
2151                            || !info->symbolic
2152                            || (h->elf_link_hash_flags
2153                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2154                 {
2155                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2156                   outrel.r_addend = rel->r_addend;
2157                 }
2158               else
2159                 {
2160                   /* This symbol is local, or marked to become local.  */
2161                   if (r_type == R_X86_64_64)
2162                     {
2163                       relocate = TRUE;
2164                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2165                       outrel.r_addend = relocation + rel->r_addend;
2166                     }
2167                   else
2168                     {
2169                       long sindx;
2170
2171                       if (h == NULL)
2172                         sec = local_sections[r_symndx];
2173                       else
2174                         {
2175                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2176                                       || (h->root.type
2177                                           == bfd_link_hash_defweak));
2178                           sec = h->root.u.def.section;
2179                         }
2180                       if (sec != NULL && bfd_is_abs_section (sec))
2181                         sindx = 0;
2182                       else if (sec == NULL || sec->owner == NULL)
2183                         {
2184                           bfd_set_error (bfd_error_bad_value);
2185                           return FALSE;
2186                         }
2187                       else
2188                         {
2189                           asection *osec;
2190
2191                           osec = sec->output_section;
2192                           sindx = elf_section_data (osec)->dynindx;
2193                           BFD_ASSERT (sindx > 0);
2194                         }
2195
2196                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2197                       outrel.r_addend = relocation + rel->r_addend;
2198                     }
2199                 }
2200
2201               sreloc = elf_section_data (input_section)->sreloc;
2202               if (sreloc == NULL)
2203                 abort ();
2204
2205               loc = sreloc->contents;
2206               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2207               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2208
2209               /* If this reloc is against an external symbol, we do
2210                  not want to fiddle with the addend.  Otherwise, we
2211                  need to include the symbol value so that it becomes
2212                  an addend for the dynamic reloc.  */
2213               if (! relocate)
2214                 continue;
2215             }
2216
2217           break;
2218
2219         case R_X86_64_TLSGD:
2220         case R_X86_64_GOTTPOFF:
2221           r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
2222           tls_type = GOT_UNKNOWN;
2223           if (h == NULL && local_got_offsets)
2224             tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
2225           else if (h != NULL)
2226             {
2227               tls_type = elf64_x86_64_hash_entry (h)->tls_type;
2228               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2229                 r_type = R_X86_64_TPOFF32;
2230             }
2231           if (r_type == R_X86_64_TLSGD)
2232             {
2233               if (tls_type == GOT_TLS_IE)
2234                 r_type = R_X86_64_GOTTPOFF;
2235             }
2236
2237           if (r_type == R_X86_64_TPOFF32)
2238             {
2239               BFD_ASSERT (! unresolved_reloc);
2240               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
2241                 {
2242                   unsigned int i;
2243                   static unsigned char tlsgd[8]
2244                     = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2245
2246                   /* GD->LE transition.
2247                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2248                      .word 0x6666; rex64; call __tls_get_addr@plt
2249                      Change it into:
2250                      movq %fs:0, %rax
2251                      leaq foo@tpoff(%rax), %rax */
2252                   BFD_ASSERT (rel->r_offset >= 4);
2253                   for (i = 0; i < 4; i++)
2254                     BFD_ASSERT (bfd_get_8 (input_bfd,
2255                                            contents + rel->r_offset - 4 + i)
2256                                 == tlsgd[i]);
2257                   BFD_ASSERT (rel->r_offset + 12 <= input_section->_raw_size);
2258                   for (i = 0; i < 4; i++)
2259                     BFD_ASSERT (bfd_get_8 (input_bfd,
2260                                            contents + rel->r_offset + 4 + i)
2261                                 == tlsgd[i+4]);
2262                   BFD_ASSERT (rel + 1 < relend);
2263                   BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2264                   memcpy (contents + rel->r_offset - 4,
2265                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2266                           16);
2267                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2268                               contents + rel->r_offset + 8);
2269                   /* Skip R_X86_64_PLT32.  */
2270                   rel++;
2271                   continue;
2272                 }
2273               else
2274                 {
2275                   unsigned int val, type, reg;
2276
2277                   /* IE->LE transition:
2278                      Originally it can be one of:
2279                      movq foo@gottpoff(%rip), %reg
2280                      addq foo@gottpoff(%rip), %reg
2281                      We change it into:
2282                      movq $foo, %reg
2283                      leaq foo(%reg), %reg
2284                      addq $foo, %reg.  */
2285                   BFD_ASSERT (rel->r_offset >= 3);
2286                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3);
2287                   BFD_ASSERT (val == 0x48 || val == 0x4c);
2288                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2289                   BFD_ASSERT (type == 0x8b || type == 0x03);
2290                   reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2291                   BFD_ASSERT ((reg & 0xc7) == 5);
2292                   reg >>= 3;
2293                   BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2294                   if (type == 0x8b)
2295                     {
2296                       /* movq */
2297                       if (val == 0x4c)
2298                         bfd_put_8 (output_bfd, 0x49,
2299                                    contents + rel->r_offset - 3);
2300                       bfd_put_8 (output_bfd, 0xc7,
2301                                  contents + rel->r_offset - 2);
2302                       bfd_put_8 (output_bfd, 0xc0 | reg,
2303                                  contents + rel->r_offset - 1);
2304                     }
2305                   else if (reg == 4)
2306                     {
2307                       /* addq -> addq - addressing with %rsp/%r12 is
2308                          special  */
2309                       if (val == 0x4c)
2310                         bfd_put_8 (output_bfd, 0x49,
2311                                    contents + rel->r_offset - 3);
2312                       bfd_put_8 (output_bfd, 0x81,
2313                                  contents + rel->r_offset - 2);
2314                       bfd_put_8 (output_bfd, 0xc0 | reg,
2315                                  contents + rel->r_offset - 1);
2316                     }
2317                   else
2318                     {
2319                       /* addq -> leaq */
2320                       if (val == 0x4c)
2321                         bfd_put_8 (output_bfd, 0x4d,
2322                                    contents + rel->r_offset - 3);
2323                       bfd_put_8 (output_bfd, 0x8d,
2324                                  contents + rel->r_offset - 2);
2325                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
2326                                  contents + rel->r_offset - 1);
2327                     }
2328                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2329                               contents + rel->r_offset);
2330                   continue;
2331                 }
2332             }
2333
2334           if (htab->sgot == NULL)
2335             abort ();
2336
2337           if (h != NULL)
2338             off = h->got.offset;
2339           else
2340             {
2341               if (local_got_offsets == NULL)
2342                 abort ();
2343
2344               off = local_got_offsets[r_symndx];
2345             }
2346
2347           if ((off & 1) != 0)
2348             off &= ~1;
2349           else
2350             {
2351               Elf_Internal_Rela outrel;
2352               bfd_byte *loc;
2353               int dr_type, indx;
2354
2355               if (htab->srelgot == NULL)
2356                 abort ();
2357
2358               outrel.r_offset = (htab->sgot->output_section->vma
2359                                  + htab->sgot->output_offset + off);
2360
2361               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2362               if (r_type == R_X86_64_TLSGD)
2363                 dr_type = R_X86_64_DTPMOD64;
2364               else
2365                 dr_type = R_X86_64_TPOFF64;
2366
2367               bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
2368               outrel.r_addend = 0;
2369               if (dr_type == R_X86_64_TPOFF64 && indx == 0)
2370                 outrel.r_addend = relocation - dtpoff_base (info);
2371               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2372
2373               loc = htab->srelgot->contents;
2374               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2375               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2376
2377               if (r_type == R_X86_64_TLSGD)
2378                 {
2379                   if (indx == 0)
2380                     {
2381                       BFD_ASSERT (! unresolved_reloc);
2382                       bfd_put_64 (output_bfd,
2383                                   relocation - dtpoff_base (info),
2384                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2385                     }
2386                   else
2387                     {
2388                       bfd_put_64 (output_bfd, 0,
2389                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2390                       outrel.r_info = ELF64_R_INFO (indx,
2391                                                     R_X86_64_DTPOFF64);
2392                       outrel.r_offset += GOT_ENTRY_SIZE;
2393                       htab->srelgot->reloc_count++;
2394                       loc += sizeof (Elf64_External_Rela);
2395                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2396                     }
2397                 }
2398
2399               if (h != NULL)
2400                 h->got.offset |= 1;
2401               else
2402                 local_got_offsets[r_symndx] |= 1;
2403             }
2404
2405           if (off >= (bfd_vma) -2)
2406             abort ();
2407           if (r_type == ELF64_R_TYPE (rel->r_info))
2408             {
2409               relocation = htab->sgot->output_section->vma
2410                            + htab->sgot->output_offset + off;
2411               unresolved_reloc = FALSE;
2412             }
2413           else
2414             {
2415               unsigned int i;
2416               static unsigned char tlsgd[8]
2417                 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2418
2419               /* GD->IE transition.
2420                  .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2421                  .word 0x6666; rex64; call __tls_get_addr@plt
2422                  Change it into:
2423                  movq %fs:0, %rax
2424                  addq foo@gottpoff(%rip), %rax */
2425               BFD_ASSERT (rel->r_offset >= 4);
2426               for (i = 0; i < 4; i++)
2427                 BFD_ASSERT (bfd_get_8 (input_bfd,
2428                                        contents + rel->r_offset - 4 + i)
2429                             == tlsgd[i]);
2430               BFD_ASSERT (rel->r_offset + 12 <= input_section->_raw_size);
2431               for (i = 0; i < 4; i++)
2432                 BFD_ASSERT (bfd_get_8 (input_bfd,
2433                                        contents + rel->r_offset + 4 + i)
2434                             == tlsgd[i+4]);
2435               BFD_ASSERT (rel + 1 < relend);
2436               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2437               memcpy (contents + rel->r_offset - 4,
2438                       "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2439                       16);
2440
2441               relocation = (htab->sgot->output_section->vma
2442                             + htab->sgot->output_offset + off
2443                             - rel->r_offset
2444                             - input_section->output_section->vma
2445                             - input_section->output_offset
2446                             - 12);
2447               bfd_put_32 (output_bfd, relocation,
2448                           contents + rel->r_offset + 8);
2449               /* Skip R_X86_64_PLT32.  */
2450               rel++;
2451               continue;
2452             }
2453           break;
2454
2455         case R_X86_64_TLSLD:
2456           if (! info->shared)
2457             {
2458               /* LD->LE transition:
2459                  Ensure it is:
2460                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2461                  We change it into:
2462                  .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
2463               BFD_ASSERT (rel->r_offset >= 3);
2464               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3)
2465                           == 0x48);
2466               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2467                           == 0x8d);
2468               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1)
2469                           == 0x3d);
2470               BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2471               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2472                           == 0xe8);
2473               BFD_ASSERT (rel + 1 < relend);
2474               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2475               memcpy (contents + rel->r_offset - 3,
2476                       "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2477               /* Skip R_X86_64_PLT32.  */
2478               rel++;
2479               continue;
2480             }
2481
2482           if (htab->sgot == NULL)
2483             abort ();
2484
2485           off = htab->tls_ld_got.offset;
2486           if (off & 1)
2487             off &= ~1;
2488           else
2489             {
2490               Elf_Internal_Rela outrel;
2491               bfd_byte *loc;
2492
2493               if (htab->srelgot == NULL)
2494                 abort ();
2495
2496               outrel.r_offset = (htab->sgot->output_section->vma
2497                                  + htab->sgot->output_offset + off);
2498
2499               bfd_put_64 (output_bfd, 0,
2500                           htab->sgot->contents + off);
2501               bfd_put_64 (output_bfd, 0,
2502                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2503               outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
2504               outrel.r_addend = 0;
2505               loc = htab->srelgot->contents;
2506               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2507               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2508               htab->tls_ld_got.offset |= 1;
2509             }
2510           relocation = htab->sgot->output_section->vma
2511                        + htab->sgot->output_offset + off;
2512           unresolved_reloc = FALSE;
2513           break;
2514
2515         case R_X86_64_DTPOFF32:
2516           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2517             relocation -= dtpoff_base (info);
2518           else
2519             relocation = tpoff (info, relocation);
2520           break;
2521
2522         case R_X86_64_TPOFF32:
2523           BFD_ASSERT (! info->shared);
2524           relocation = tpoff (info, relocation);
2525           break;
2526
2527         default:
2528           break;
2529         }
2530
2531       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2532          because such sections are not SEC_ALLOC and thus ld.so will
2533          not process them.  */
2534       if (unresolved_reloc
2535           && !((input_section->flags & SEC_DEBUGGING) != 0
2536                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2537         (*_bfd_error_handler)
2538           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2539            bfd_archive_filename (input_bfd),
2540            bfd_get_section_name (input_bfd, input_section),
2541            (long) rel->r_offset,
2542            h->root.root.string);
2543
2544       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2545                                     contents, rel->r_offset,
2546                                     relocation, rel->r_addend);
2547
2548       if (r != bfd_reloc_ok)
2549         {
2550           const char *name;
2551
2552           if (h != NULL)
2553             name = h->root.root.string;
2554           else
2555             {
2556               name = bfd_elf_string_from_elf_section (input_bfd,
2557                                                       symtab_hdr->sh_link,
2558                                                       sym->st_name);
2559               if (name == NULL)
2560                 return FALSE;
2561               if (*name == '\0')
2562                 name = bfd_section_name (input_bfd, sec);
2563             }
2564
2565           if (r == bfd_reloc_overflow)
2566             {
2567
2568               if (! ((*info->callbacks->reloc_overflow)
2569                      (info, name, howto->name, (bfd_vma) 0,
2570                       input_bfd, input_section, rel->r_offset)))
2571                 return FALSE;
2572             }
2573           else
2574             {
2575               (*_bfd_error_handler)
2576                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2577                  bfd_archive_filename (input_bfd),
2578                  bfd_get_section_name (input_bfd, input_section),
2579                  (long) rel->r_offset, name, (int) r);
2580               return FALSE;
2581             }
2582         }
2583     }
2584
2585   return TRUE;
2586 }
2587
2588 /* Finish up dynamic symbol handling.  We set the contents of various
2589    dynamic sections here.  */
2590
2591 static bfd_boolean
2592 elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
2593      bfd *output_bfd;
2594      struct bfd_link_info *info;
2595      struct elf_link_hash_entry *h;
2596      Elf_Internal_Sym *sym;
2597 {
2598   struct elf64_x86_64_link_hash_table *htab;
2599
2600   htab = elf64_x86_64_hash_table (info);
2601
2602   if (h->plt.offset != (bfd_vma) -1)
2603     {
2604       bfd_vma plt_index;
2605       bfd_vma got_offset;
2606       Elf_Internal_Rela rela;
2607       bfd_byte *loc;
2608
2609       /* This symbol has an entry in the procedure linkage table.  Set
2610          it up.  */
2611       if (h->dynindx == -1
2612           || htab->splt == NULL
2613           || htab->sgotplt == NULL
2614           || htab->srelplt == NULL)
2615         abort ();
2616
2617       /* Get the index in the procedure linkage table which
2618          corresponds to this symbol.  This is the index of this symbol
2619          in all the symbols for which we are making plt entries.  The
2620          first entry in the procedure linkage table is reserved.  */
2621       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2622
2623       /* Get the offset into the .got table of the entry that
2624          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
2625          bytes. The first three are reserved for the dynamic linker.  */
2626       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2627
2628       /* Fill in the entry in the procedure linkage table.  */
2629       memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
2630               PLT_ENTRY_SIZE);
2631
2632       /* Insert the relocation positions of the plt section.  The magic
2633          numbers at the end of the statements are the positions of the
2634          relocations in the plt section.  */
2635       /* Put offset for jmp *name@GOTPCREL(%rip), since the
2636          instruction uses 6 bytes, subtract this value.  */
2637       bfd_put_32 (output_bfd,
2638                       (htab->sgotplt->output_section->vma
2639                        + htab->sgotplt->output_offset
2640                        + got_offset
2641                        - htab->splt->output_section->vma
2642                        - htab->splt->output_offset
2643                        - h->plt.offset
2644                        - 6),
2645                   htab->splt->contents + h->plt.offset + 2);
2646       /* Put relocation index.  */
2647       bfd_put_32 (output_bfd, plt_index,
2648                   htab->splt->contents + h->plt.offset + 7);
2649       /* Put offset for jmp .PLT0.  */
2650       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2651                   htab->splt->contents + h->plt.offset + 12);
2652
2653       /* Fill in the entry in the global offset table, initially this
2654          points to the pushq instruction in the PLT which is at offset 6.  */
2655       bfd_put_64 (output_bfd, (htab->splt->output_section->vma
2656                                + htab->splt->output_offset
2657                                + h->plt.offset + 6),
2658                   htab->sgotplt->contents + got_offset);
2659
2660       /* Fill in the entry in the .rela.plt section.  */
2661       rela.r_offset = (htab->sgotplt->output_section->vma
2662                        + htab->sgotplt->output_offset
2663                        + got_offset);
2664       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
2665       rela.r_addend = 0;
2666       loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
2667       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2668
2669       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2670         {
2671           /* Mark the symbol as undefined, rather than as defined in
2672              the .plt section.  Leave the value alone.  This is a clue
2673              for the dynamic linker, to make function pointer
2674              comparisons work between an application and shared
2675              library.  */
2676           sym->st_shndx = SHN_UNDEF;
2677         }
2678     }
2679
2680   if (h->got.offset != (bfd_vma) -1
2681       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_GD
2682       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
2683     {
2684       Elf_Internal_Rela rela;
2685       bfd_byte *loc;
2686
2687       /* This symbol has an entry in the global offset table.  Set it
2688          up.  */
2689       if (htab->sgot == NULL || htab->srelgot == NULL)
2690         abort ();
2691
2692       rela.r_offset = (htab->sgot->output_section->vma
2693                        + htab->sgot->output_offset
2694                        + (h->got.offset &~ (bfd_vma) 1));
2695
2696       /* If this is a static link, or it is a -Bsymbolic link and the
2697          symbol is defined locally or was forced to be local because
2698          of a version file, we just want to emit a RELATIVE reloc.
2699          The entry in the global offset table will already have been
2700          initialized in the relocate_section function.  */
2701       if (info->shared
2702           && (info->symbolic
2703               || h->dynindx == -1
2704               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2705           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2706         {
2707           BFD_ASSERT((h->got.offset & 1) != 0);
2708           rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2709           rela.r_addend = (h->root.u.def.value
2710                            + h->root.u.def.section->output_section->vma
2711                            + h->root.u.def.section->output_offset);
2712         }
2713       else
2714         {
2715           BFD_ASSERT((h->got.offset & 1) == 0);
2716           bfd_put_64 (output_bfd, (bfd_vma) 0,
2717                       htab->sgot->contents + h->got.offset);
2718           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
2719           rela.r_addend = 0;
2720         }
2721
2722       loc = htab->srelgot->contents;
2723       loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2724       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2725     }
2726
2727   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2728     {
2729       Elf_Internal_Rela rela;
2730       bfd_byte *loc;
2731
2732       /* This symbol needs a copy reloc.  Set it up.  */
2733
2734       if (h->dynindx == -1
2735           || (h->root.type != bfd_link_hash_defined
2736               && h->root.type != bfd_link_hash_defweak)
2737           || htab->srelbss == NULL)
2738         abort ();
2739
2740       rela.r_offset = (h->root.u.def.value
2741                        + h->root.u.def.section->output_section->vma
2742                        + h->root.u.def.section->output_offset);
2743       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
2744       rela.r_addend = 0;
2745       loc = htab->srelbss->contents;
2746       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
2747       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2748     }
2749
2750   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2751   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2752       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2753     sym->st_shndx = SHN_ABS;
2754
2755   return TRUE;
2756 }
2757
2758 /* Used to decide how to sort relocs in an optimal manner for the
2759    dynamic linker, before writing them out.  */
2760
2761 static enum elf_reloc_type_class
2762 elf64_x86_64_reloc_type_class (rela)
2763      const Elf_Internal_Rela *rela;
2764 {
2765   switch ((int) ELF64_R_TYPE (rela->r_info))
2766     {
2767     case R_X86_64_RELATIVE:
2768       return reloc_class_relative;
2769     case R_X86_64_JUMP_SLOT:
2770       return reloc_class_plt;
2771     case R_X86_64_COPY:
2772       return reloc_class_copy;
2773     default:
2774       return reloc_class_normal;
2775     }
2776 }
2777
2778 /* Finish up the dynamic sections.  */
2779
2780 static bfd_boolean
2781 elf64_x86_64_finish_dynamic_sections (output_bfd, info)
2782      bfd *output_bfd;
2783      struct bfd_link_info *info;
2784 {
2785   struct elf64_x86_64_link_hash_table *htab;
2786   bfd *dynobj;
2787   asection *sdyn;
2788
2789   htab = elf64_x86_64_hash_table (info);
2790   dynobj = htab->elf.dynobj;
2791   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2792
2793   if (htab->elf.dynamic_sections_created)
2794     {
2795       Elf64_External_Dyn *dyncon, *dynconend;
2796
2797       if (sdyn == NULL || htab->sgot == NULL)
2798         abort ();
2799
2800       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2801       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2802       for (; dyncon < dynconend; dyncon++)
2803         {
2804           Elf_Internal_Dyn dyn;
2805           asection *s;
2806
2807           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2808
2809           switch (dyn.d_tag)
2810             {
2811             default:
2812               continue;
2813
2814             case DT_PLTGOT:
2815               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2816               break;
2817
2818             case DT_JMPREL:
2819               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2820               break;
2821
2822             case DT_PLTRELSZ:
2823               s = htab->srelplt->output_section;
2824               if (s->_cooked_size != 0)
2825                 dyn.d_un.d_val = s->_cooked_size;
2826               else
2827                 dyn.d_un.d_val = s->_raw_size;
2828               break;
2829
2830             case DT_RELASZ:
2831               /* The procedure linkage table relocs (DT_JMPREL) should
2832                  not be included in the overall relocs (DT_RELA).
2833                  Therefore, we override the DT_RELASZ entry here to
2834                  make it not include the JMPREL relocs.  Since the
2835                  linker script arranges for .rela.plt to follow all
2836                  other relocation sections, we don't have to worry
2837                  about changing the DT_RELA entry.  */
2838               if (htab->srelplt != NULL)
2839                 {
2840                   s = htab->srelplt->output_section;
2841                   if (s->_cooked_size != 0)
2842                     dyn.d_un.d_val -= s->_cooked_size;
2843                   else
2844                     dyn.d_un.d_val -= s->_raw_size;
2845                 }
2846               break;
2847             }
2848
2849           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2850         }
2851
2852       /* Fill in the special first entry in the procedure linkage table.  */
2853       if (htab->splt && htab->splt->_raw_size > 0)
2854         {
2855           /* Fill in the first entry in the procedure linkage table.  */
2856           memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
2857                   PLT_ENTRY_SIZE);
2858           /* Add offset for pushq GOT+8(%rip), since the instruction
2859              uses 6 bytes subtract this value.  */
2860           bfd_put_32 (output_bfd,
2861                       (htab->sgotplt->output_section->vma
2862                        + htab->sgotplt->output_offset
2863                        + 8
2864                        - htab->splt->output_section->vma
2865                        - htab->splt->output_offset
2866                        - 6),
2867                       htab->splt->contents + 2);
2868           /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2869              the end of the instruction.  */
2870           bfd_put_32 (output_bfd,
2871                       (htab->sgotplt->output_section->vma
2872                        + htab->sgotplt->output_offset
2873                        + 16
2874                        - htab->splt->output_section->vma
2875                        - htab->splt->output_offset
2876                        - 12),
2877                       htab->splt->contents + 8);
2878
2879           elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
2880             PLT_ENTRY_SIZE;
2881         }
2882     }
2883
2884   if (htab->sgotplt)
2885     {
2886       /* Fill in the first three entries in the global offset table.  */
2887       if (htab->sgotplt->_raw_size > 0)
2888         {
2889           /* Set the first entry in the global offset table to the address of
2890              the dynamic section.  */
2891           if (sdyn == NULL)
2892             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
2893           else
2894             bfd_put_64 (output_bfd,
2895                         sdyn->output_section->vma + sdyn->output_offset,
2896                         htab->sgotplt->contents);
2897           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
2898           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
2899           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
2900         }
2901
2902       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
2903         GOT_ENTRY_SIZE;
2904     }
2905
2906   return TRUE;
2907 }
2908
2909
2910 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
2911 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
2912 #define ELF_ARCH                            bfd_arch_i386
2913 #define ELF_MACHINE_CODE                    EM_X86_64
2914 #define ELF_MAXPAGESIZE                     0x100000
2915
2916 #define elf_backend_can_gc_sections         1
2917 #define elf_backend_can_refcount            1
2918 #define elf_backend_want_got_plt            1
2919 #define elf_backend_plt_readonly            1
2920 #define elf_backend_want_plt_sym            0
2921 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
2922 #define elf_backend_plt_header_size         PLT_ENTRY_SIZE
2923 #define elf_backend_rela_normal             1
2924
2925 #define elf_info_to_howto                   elf64_x86_64_info_to_howto
2926
2927 #define bfd_elf64_bfd_link_hash_table_create \
2928   elf64_x86_64_link_hash_table_create
2929 #define bfd_elf64_bfd_reloc_type_lookup     elf64_x86_64_reloc_type_lookup
2930
2931 #define elf_backend_adjust_dynamic_symbol   elf64_x86_64_adjust_dynamic_symbol
2932 #define elf_backend_check_relocs            elf64_x86_64_check_relocs
2933 #define elf_backend_copy_indirect_symbol    elf64_x86_64_copy_indirect_symbol
2934 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
2935 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
2936 #define elf_backend_finish_dynamic_symbol   elf64_x86_64_finish_dynamic_symbol
2937 #define elf_backend_gc_mark_hook            elf64_x86_64_gc_mark_hook
2938 #define elf_backend_gc_sweep_hook           elf64_x86_64_gc_sweep_hook
2939 #define elf_backend_grok_prstatus           elf64_x86_64_grok_prstatus
2940 #define elf_backend_grok_psinfo             elf64_x86_64_grok_psinfo
2941 #define elf_backend_reloc_type_class        elf64_x86_64_reloc_type_class
2942 #define elf_backend_relocate_section        elf64_x86_64_relocate_section
2943 #define elf_backend_size_dynamic_sections   elf64_x86_64_size_dynamic_sections
2944 #define elf_backend_object_p                elf64_x86_64_elf_object_p
2945 #define bfd_elf64_mkobject                  elf64_x86_64_mkobject
2946
2947 #include "elf64-target.h"