bfd/elf64-x86-64.c

   1 /* X86-64 specific support for ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Jan Hubicka <jh@suse.cz>.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf-nacl.h"
  30 #include "bfd_stdint.h"
  31 #include "objalloc.h"
  32 #include "hashtab.h"
  33 #include "dwarf2.h"
  34 #include "libiberty.h"
  35
  36 #include "elf/x86-64.h"
  37
  38 #ifdef CORE_HEADER
  39 #include <stdarg.h>
  40 #include CORE_HEADER
  41 #endif
  42
  43 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  44 #define MINUS_ONE (~ (bfd_vma) 0)
  45
  46 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
  47    identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
  48    relocation type.  We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
  49    since they are the same.  */
  50
  51 #define ABI_64_P(abfd) \
  52   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
  53
  54 /* The relocation "howto" table.  Order of fields:
  55    type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
  56    special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset.  */
  57 static reloc_howto_type x86_64_elf_howto_table[] =
  58 {
  59   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
  60         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
  61         FALSE),
  62   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  63         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
  64         FALSE),
  65   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  66         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
  67         TRUE),
  68   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  69         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
  70         FALSE),
  71   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  72         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
  73         TRUE),
  74   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  75         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
  76         FALSE),
  77   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  78         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
  79         MINUS_ONE, FALSE),
  80   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  81         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
  82         MINUS_ONE, FALSE),
  83   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  84         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
  85         MINUS_ONE, FALSE),
  86   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  87         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
  88         0xffffffff, TRUE),
  89   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
  90         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
  91         FALSE),
  92   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  93         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
  94         FALSE),
  95   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  96         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
  97   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  98         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
  99   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
 101   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 102         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
 103   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 104         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
 105         MINUS_ONE, FALSE),
 106   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 107         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
 108         MINUS_ONE, FALSE),
 109   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 110         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
 111         MINUS_ONE, FALSE),
 112   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 113         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
 114         0xffffffff, TRUE),
 115   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 116         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
 117         0xffffffff, TRUE),
 118   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 119         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
 120         0xffffffff, FALSE),
 121   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 122         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
 123         0xffffffff, TRUE),
 124   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 125         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
 126         0xffffffff, FALSE),
 127   HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
 128         bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
 129         TRUE),
 130   HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
 132         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 133   HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 134         bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
 135         FALSE, 0xffffffff, 0xffffffff, TRUE),
 136   HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 137         bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
 138         FALSE),
 139   HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 140         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
 141         MINUS_ONE, TRUE),
 142   HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 143         bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
 144         FALSE, MINUS_ONE, MINUS_ONE, TRUE),
 145   HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 146         bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
 147         MINUS_ONE, FALSE),
 148   HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 149         bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
 150         MINUS_ONE, FALSE),
 151   HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
 152         bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
 153         FALSE),
 154   HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
 155         bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
 156         FALSE),
 157   HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
 158         complain_overflow_bitfield, bfd_elf_generic_reloc,
 159         "R_X86_64_GOTPC32_TLSDESC",
 160         FALSE, 0xffffffff, 0xffffffff, TRUE),
 161   HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
 162         complain_overflow_dont, bfd_elf_generic_reloc,
 163         "R_X86_64_TLSDESC_CALL",
 164         FALSE, 0, 0, FALSE),
 165   HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
 166         complain_overflow_bitfield, bfd_elf_generic_reloc,
 167         "R_X86_64_TLSDESC",
 168         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 169   HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 170         bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
 171         MINUS_ONE, FALSE),
 172   HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 173         bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
 174         MINUS_ONE, FALSE),
 175
 176   /* We have a gap in the reloc numbers here.
 177      R_X86_64_standard counts the number up to this point, and
 178      R_X86_64_vt_offset is the value to subtract from a reloc type of
 179      R_X86_64_GNU_VT* to form an index into this table.  */
 180 #define R_X86_64_standard (R_X86_64_RELATIVE64 + 1)
 181 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
 182
 183 /* GNU extension to record C++ vtable hierarchy.  */
 184   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 185          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 186
 187 /* GNU extension to record C++ vtable member usage.  */
 188   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 189          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 190          FALSE),
 191
 192 /* Use complain_overflow_bitfield on R_X86_64_32 for x32.  */
 193   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 194         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
 195         FALSE)
 196 };
 197
 198 #define IS_X86_64_PCREL_TYPE(TYPE)      \
 199   (   ((TYPE) == R_X86_64_PC8)          \
 200    || ((TYPE) == R_X86_64_PC16)         \
 201    || ((TYPE) == R_X86_64_PC32)         \
 202    || ((TYPE) == R_X86_64_PC64))
 203
 204 /* Map BFD relocs to the x86_64 elf relocs.  */
 205 struct elf_reloc_map
 206 {
 207   bfd_reloc_code_real_type bfd_reloc_val;
 208   unsigned char elf_reloc_val;
 209 };
 210
 211 static const struct elf_reloc_map x86_64_reloc_map[] =
 212 {
 213   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 214   { BFD_RELOC_64,               R_X86_64_64,   },
 215   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 216   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 217   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 218   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 219   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 220   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 221   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 222   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 223   { BFD_RELOC_32,               R_X86_64_32, },
 224   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 225   { BFD_RELOC_16,               R_X86_64_16, },
 226   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 227   { BFD_RELOC_8,                R_X86_64_8, },
 228   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 229   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 230   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 231   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 232   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 233   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 234   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 235   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 236   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 237   { BFD_RELOC_64_PCREL,         R_X86_64_PC64, },
 238   { BFD_RELOC_X86_64_GOTOFF64,  R_X86_64_GOTOFF64, },
 239   { BFD_RELOC_X86_64_GOTPC32,   R_X86_64_GOTPC32, },
 240   { BFD_RELOC_X86_64_GOT64,     R_X86_64_GOT64, },
 241   { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
 242   { BFD_RELOC_X86_64_GOTPC64,   R_X86_64_GOTPC64, },
 243   { BFD_RELOC_X86_64_GOTPLT64,  R_X86_64_GOTPLT64, },
 244   { BFD_RELOC_X86_64_PLTOFF64,  R_X86_64_PLTOFF64, },
 245   { BFD_RELOC_SIZE32,           R_X86_64_SIZE32, },
 246   { BFD_RELOC_SIZE64,           R_X86_64_SIZE64, },
 247   { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
 248   { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
 249   { BFD_RELOC_X86_64_TLSDESC,   R_X86_64_TLSDESC, },
 250   { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
 251   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 252   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 253 };
 254
 255 static reloc_howto_type *
 256 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
 257 {
 258   unsigned i;
 259
 260   if (r_type == (unsigned int) R_X86_64_32)
 261     {
 262       if (ABI_64_P (abfd))
 263         i = r_type;
 264       else
 265         i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
 266     }
 267   else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
 268            || r_type >= (unsigned int) R_X86_64_max)
 269     {
 270       if (r_type >= (unsigned int) R_X86_64_standard)
 271         {
 272           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 273                                  abfd, (int) r_type);
 274           r_type = R_X86_64_NONE;
 275         }
 276       i = r_type;
 277     }
 278   else
 279     i = r_type - (unsigned int) R_X86_64_vt_offset;
 280   BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
 281   return &x86_64_elf_howto_table[i];
 282 }
 283
 284 /* Given a BFD reloc type, return a HOWTO structure.  */
 285 static reloc_howto_type *
 286 elf_x86_64_reloc_type_lookup (bfd *abfd,
 287                               bfd_reloc_code_real_type code)
 288 {
 289   unsigned int i;
 290
 291   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 292        i++)
 293     {
 294       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 295         return elf_x86_64_rtype_to_howto (abfd,
 296                                           x86_64_reloc_map[i].elf_reloc_val);
 297     }
 298   return 0;
 299 }
 300
 301 static reloc_howto_type *
 302 elf_x86_64_reloc_name_lookup (bfd *abfd,
 303                               const char *r_name)
 304 {
 305   unsigned int i;
 306
 307   if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
 308     {
 309       /* Get x32 R_X86_64_32.  */
 310       reloc_howto_type *reloc
 311         = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
 312       BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
 313       return reloc;
 314     }
 315
 316   for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
 317     if (x86_64_elf_howto_table[i].name != NULL
 318         && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
 319       return &x86_64_elf_howto_table[i];
 320
 321   return NULL;
 322 }
 323
 324 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 325
 326 static void
 327 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 328                           Elf_Internal_Rela *dst)
 329 {
 330   unsigned r_type;
 331
 332   r_type = ELF32_R_TYPE (dst->r_info);
 333   cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
 334   BFD_ASSERT (r_type == cache_ptr->howto->type);
 335 }
 336 \f
 337 /* Support for core dump NOTE sections.  */
 338 static bfd_boolean
 339 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 340 {
 341   int offset;
 342   size_t size;
 343
 344   switch (note->descsz)
 345     {
 346       default:
 347         return FALSE;
 348
 349       case 296:         /* sizeof(istruct elf_prstatus) on Linux/x32 */
 350         /* pr_cursig */
 351         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 352
 353         /* pr_pid */
 354         elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
 355
 356         /* pr_reg */
 357         offset = 72;
 358         size = 216;
 359
 360         break;
 361
 362       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 363         /* pr_cursig */
 364         elf_tdata (abfd)->core_signal
 365           = bfd_get_16 (abfd, note->descdata + 12);
 366
 367         /* pr_pid */
 368         elf_tdata (abfd)->core_lwpid
 369           = bfd_get_32 (abfd, note->descdata + 32);
 370
 371         /* pr_reg */
 372         offset = 112;
 373         size = 216;
 374
 375         break;
 376     }
 377
 378   /* Make a ".reg/999" section.  */
 379   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 380                                           size, note->descpos + offset);
 381 }
 382
 383 static bfd_boolean
 384 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 385 {
 386   switch (note->descsz)
 387     {
 388       default:
 389         return FALSE;
 390
 391       case 124:         /* sizeof(struct elf_prpsinfo) on Linux/x32 */
 392         elf_tdata (abfd)->core_pid
 393           = bfd_get_32 (abfd, note->descdata + 12);
 394         elf_tdata (abfd)->core_program
 395           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 396         elf_tdata (abfd)->core_command
 397           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 398         break;
 399
 400       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 401         elf_tdata (abfd)->core_pid
 402           = bfd_get_32 (abfd, note->descdata + 24);
 403         elf_tdata (abfd)->core_program
 404          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 405         elf_tdata (abfd)->core_command
 406          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 407     }
 408
 409   /* Note that for some reason, a spurious space is tacked
 410      onto the end of the args in some (at least one anyway)
 411      implementations, so strip it off if it exists.  */
 412
 413   {
 414     char *command = elf_tdata (abfd)->core_command;
 415     int n = strlen (command);
 416
 417     if (0 < n && command[n - 1] == ' ')
 418       command[n - 1] = '\0';
 419   }
 420
 421   return TRUE;
 422 }
 423
 424 #ifdef CORE_HEADER
 425 static char *
 426 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
 427                             int note_type, ...)
 428 {
 429   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 430   va_list ap;
 431   const char *fname, *psargs;
 432   long pid;
 433   int cursig;
 434   const void *gregs;
 435
 436   switch (note_type)
 437     {
 438     default:
 439       return NULL;
 440
 441     case NT_PRPSINFO:
 442       va_start (ap, note_type);
 443       fname = va_arg (ap, const char *);
 444       psargs = va_arg (ap, const char *);
 445       va_end (ap);
 446
 447       if (bed->s->elfclass == ELFCLASS32)
 448         {
 449           prpsinfo32_t data;
 450           memset (&data, 0, sizeof (data));
 451           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 452           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 453           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 454                                      &data, sizeof (data));
 455         }
 456       else
 457         {
 458           prpsinfo64_t data;
 459           memset (&data, 0, sizeof (data));
 460           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 461           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 462           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 463                                      &data, sizeof (data));
 464         }
 465       /* NOTREACHED */
 466
 467     case NT_PRSTATUS:
 468       va_start (ap, note_type);
 469       pid = va_arg (ap, long);
 470       cursig = va_arg (ap, int);
 471       gregs = va_arg (ap, const void *);
 472       va_end (ap);
 473
 474       if (bed->s->elfclass == ELFCLASS32)
 475         {
 476           if (bed->elf_machine_code == EM_X86_64)
 477             {
 478               prstatusx32_t prstat;
 479               memset (&prstat, 0, sizeof (prstat));
 480               prstat.pr_pid = pid;
 481               prstat.pr_cursig = cursig;
 482               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 483               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 484                                          &prstat, sizeof (prstat));
 485             }
 486           else
 487             {
 488               prstatus32_t prstat;
 489               memset (&prstat, 0, sizeof (prstat));
 490               prstat.pr_pid = pid;
 491               prstat.pr_cursig = cursig;
 492               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 493               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 494                                          &prstat, sizeof (prstat));
 495             }
 496         }
 497       else
 498         {
 499           prstatus64_t prstat;
 500           memset (&prstat, 0, sizeof (prstat));
 501           prstat.pr_pid = pid;
 502           prstat.pr_cursig = cursig;
 503           memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 504           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 505                                      &prstat, sizeof (prstat));
 506         }
 507     }
 508   /* NOTREACHED */
 509 }
 510 #endif
 511 \f
 512 /* Functions for the x86-64 ELF linker.  */
 513
 514 /* The name of the dynamic interpreter.  This is put in the .interp
 515    section.  */
 516
 517 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 518 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
 519
 520 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 521    copying dynamic variables from a shared lib into an app's dynbss
 522    section, and instead use a dynamic relocation to point into the
 523    shared lib.  */
 524 #define ELIMINATE_COPY_RELOCS 1
 525
 526 /* The size in bytes of an entry in the global offset table.  */
 527
 528 #define GOT_ENTRY_SIZE 8
 529
 530 /* The size in bytes of an entry in the procedure linkage table.  */
 531
 532 #define PLT_ENTRY_SIZE 16
 533
 534 /* The first entry in a procedure linkage table looks like this.  See the
 535    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
 536
 537 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
 538 {
 539   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 540   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 541   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 542 };
 543
 544 /* Subsequent entries in a procedure linkage table look like this.  */
 545
 546 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
 547 {
 548   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 549   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 550   0x68,         /* pushq immediate */
 551   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 552   0xe9,         /* jmp relative */
 553   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 554 };
 555
 556 /* .eh_frame covering the .plt section.  */
 557
 558 static const bfd_byte elf_x86_64_eh_frame_plt[] =
 559 {
 560 #define PLT_CIE_LENGTH          20
 561 #define PLT_FDE_LENGTH          36
 562 #define PLT_FDE_START_OFFSET    4 + PLT_CIE_LENGTH + 8
 563 #define PLT_FDE_LEN_OFFSET      4 + PLT_CIE_LENGTH + 12
 564   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 565   0, 0, 0, 0,                   /* CIE ID */
 566   1,                            /* CIE version */
 567   'z', 'R', 0,                  /* Augmentation string */
 568   1,                            /* Code alignment factor */
 569   0x78,                         /* Data alignment factor */
 570   16,                           /* Return address column */
 571   1,                            /* Augmentation size */
 572   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 573   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 574   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 575   DW_CFA_nop, DW_CFA_nop,
 576
 577   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 578   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 579   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 580   0, 0, 0, 0,                   /* .plt size goes here */
 581   0,                            /* Augmentation size */
 582   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 583   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 584   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 585   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 586   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 587   11,                           /* Block length */
 588   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 589   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 590   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
 591   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 592   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 593 };
 594
 595 /* Architecture-specific backend data for x86-64.  */
 596
 597 struct elf_x86_64_backend_data
 598 {
 599   /* Templates for the initial PLT entry and for subsequent entries.  */
 600   const bfd_byte *plt0_entry;
 601   const bfd_byte *plt_entry;
 602   unsigned int plt_entry_size;          /* Size of each PLT entry.  */
 603
 604   /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2].  */
 605   unsigned int plt0_got1_offset;
 606   unsigned int plt0_got2_offset;
 607
 608   /* Offset of the end of the PC-relative instruction containing
 609      plt0_got2_offset.  */
 610   unsigned int plt0_got2_insn_end;
 611
 612   /* Offsets into plt_entry that are to be replaced with...  */
 613   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 614   unsigned int plt_reloc_offset;  /* ... offset into relocation table. */
 615   unsigned int plt_plt_offset;    /* ... offset to start of .plt. */
 616
 617   /* Length of the PC-relative instruction containing plt_got_offset.  */
 618   unsigned int plt_got_insn_size;
 619
 620   /* Offset of the end of the PC-relative jump to plt0_entry.  */
 621   unsigned int plt_plt_insn_end;
 622
 623   /* Offset into plt_entry where the initial value of the GOT entry points.  */
 624   unsigned int plt_lazy_offset;
 625
 626   /* .eh_frame covering the .plt section.  */
 627   const bfd_byte *eh_frame_plt;
 628   unsigned int eh_frame_plt_size;
 629 };
 630
 631 #define get_elf_x86_64_backend_data(abfd) \
 632   ((const struct elf_x86_64_backend_data *) \
 633    get_elf_backend_data (abfd)->arch_data)
 634
 635 #define GET_PLT_ENTRY_SIZE(abfd) \
 636   get_elf_x86_64_backend_data (abfd)->plt_entry_size
 637
 638 /* These are the standard parameters.  */
 639 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
 640   {
 641     elf_x86_64_plt0_entry,              /* plt0_entry */
 642     elf_x86_64_plt_entry,               /* plt_entry */
 643     sizeof (elf_x86_64_plt_entry),      /* plt_entry_size */
 644     2,                                  /* plt0_got1_offset */
 645     8,                                  /* plt0_got2_offset */
 646     12,                                 /* plt0_got2_insn_end */
 647     2,                                  /* plt_got_offset */
 648     7,                                  /* plt_reloc_offset */
 649     12,                                 /* plt_plt_offset */
 650     6,                                  /* plt_got_insn_size */
 651     PLT_ENTRY_SIZE,                     /* plt_plt_insn_end */
 652     6,                                  /* plt_lazy_offset */
 653     elf_x86_64_eh_frame_plt,            /* eh_frame_plt */
 654     sizeof (elf_x86_64_eh_frame_plt),   /* eh_frame_plt_size */
 655   };
 656
 657 #define elf_backend_arch_data   &elf_x86_64_arch_bed
 658
 659 /* x86-64 ELF linker hash entry.  */
 660
 661 struct elf_x86_64_link_hash_entry
 662 {
 663   struct elf_link_hash_entry elf;
 664
 665   /* Track dynamic relocs copied for this symbol.  */
 666   struct elf_dyn_relocs *dyn_relocs;
 667
 668 #define GOT_UNKNOWN     0
 669 #define GOT_NORMAL      1
 670 #define GOT_TLS_GD      2
 671 #define GOT_TLS_IE      3
 672 #define GOT_TLS_GDESC   4
 673 #define GOT_TLS_GD_BOTH_P(type) \
 674   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
 675 #define GOT_TLS_GD_P(type) \
 676   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
 677 #define GOT_TLS_GDESC_P(type) \
 678   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
 679 #define GOT_TLS_GD_ANY_P(type) \
 680   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
 681   unsigned char tls_type;
 682
 683   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
 684      starting at the end of the jump table.  */
 685   bfd_vma tlsdesc_got;
 686 };
 687
 688 #define elf_x86_64_hash_entry(ent) \
 689   ((struct elf_x86_64_link_hash_entry *)(ent))
 690
 691 struct elf_x86_64_obj_tdata
 692 {
 693   struct elf_obj_tdata root;
 694
 695   /* tls_type for each local got entry.  */
 696   char *local_got_tls_type;
 697
 698   /* GOTPLT entries for TLS descriptors.  */
 699   bfd_vma *local_tlsdesc_gotent;
 700 };
 701
 702 #define elf_x86_64_tdata(abfd) \
 703   ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
 704
 705 #define elf_x86_64_local_got_tls_type(abfd) \
 706   (elf_x86_64_tdata (abfd)->local_got_tls_type)
 707
 708 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
 709   (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
 710
 711 #define is_x86_64_elf(bfd)                              \
 712   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 713    && elf_tdata (bfd) != NULL                           \
 714    && elf_object_id (bfd) == X86_64_ELF_DATA)
 715
 716 static bfd_boolean
 717 elf_x86_64_mkobject (bfd *abfd)
 718 {
 719   return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
 720                                   X86_64_ELF_DATA);
 721 }
 722
 723 /* x86-64 ELF linker hash table.  */
 724
 725 struct elf_x86_64_link_hash_table
 726 {
 727   struct elf_link_hash_table elf;
 728
 729   /* Short-cuts to get to dynamic linker sections.  */
 730   asection *sdynbss;
 731   asection *srelbss;
 732   asection *plt_eh_frame;
 733
 734   union
 735   {
 736     bfd_signed_vma refcount;
 737     bfd_vma offset;
 738   } tls_ld_got;
 739
 740   /* The amount of space used by the jump slots in the GOT.  */
 741   bfd_vma sgotplt_jump_table_size;
 742
 743   /* Small local sym cache.  */
 744   struct sym_cache sym_cache;
 745
 746   bfd_vma (*r_info) (bfd_vma, bfd_vma);
 747   bfd_vma (*r_sym) (bfd_vma);
 748   unsigned int pointer_r_type;
 749   const char *dynamic_interpreter;
 750   int dynamic_interpreter_size;
 751
 752   /* _TLS_MODULE_BASE_ symbol.  */
 753   struct bfd_link_hash_entry *tls_module_base;
 754
 755   /* Used by local STT_GNU_IFUNC symbols.  */
 756   htab_t loc_hash_table;
 757   void * loc_hash_memory;
 758
 759   /* The offset into splt of the PLT entry for the TLS descriptor
 760      resolver.  Special values are 0, if not necessary (or not found
 761      to be necessary yet), and -1 if needed but not determined
 762      yet.  */
 763   bfd_vma tlsdesc_plt;
 764   /* The offset into sgot of the GOT entry used by the PLT entry
 765      above.  */
 766   bfd_vma tlsdesc_got;
 767
 768   /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt.  */
 769   bfd_vma next_jump_slot_index;
 770   /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt.  */
 771   bfd_vma next_irelative_index;
 772 };
 773
 774 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
 775
 776 #define elf_x86_64_hash_table(p) \
 777   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 778   == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
 779
 780 #define elf_x86_64_compute_jump_table_size(htab) \
 781   ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
 782
 783 /* Create an entry in an x86-64 ELF linker hash table.  */
 784
 785 static struct bfd_hash_entry *
 786 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
 787                               struct bfd_hash_table *table,
 788                               const char *string)
 789 {
 790   /* Allocate the structure if it has not already been allocated by a
 791      subclass.  */
 792   if (entry == NULL)
 793     {
 794       entry = (struct bfd_hash_entry *)
 795           bfd_hash_allocate (table,
 796                              sizeof (struct elf_x86_64_link_hash_entry));
 797       if (entry == NULL)
 798         return entry;
 799     }
 800
 801   /* Call the allocation method of the superclass.  */
 802   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 803   if (entry != NULL)
 804     {
 805       struct elf_x86_64_link_hash_entry *eh;
 806
 807       eh = (struct elf_x86_64_link_hash_entry *) entry;
 808       eh->dyn_relocs = NULL;
 809       eh->tls_type = GOT_UNKNOWN;
 810       eh->tlsdesc_got = (bfd_vma) -1;
 811     }
 812
 813   return entry;
 814 }
 815
 816 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
 817   for local symbol so that we can handle local STT_GNU_IFUNC symbols
 818   as global symbol.  We reuse indx and dynstr_index for local symbol
 819   hash since they aren't used by global symbols in this backend.  */
 820
 821 static hashval_t
 822 elf_x86_64_local_htab_hash (const void *ptr)
 823 {
 824   struct elf_link_hash_entry *h
 825     = (struct elf_link_hash_entry *) ptr;
 826   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
 827 }
 828
 829 /* Compare local hash entries.  */
 830
 831 static int
 832 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
 833 {
 834   struct elf_link_hash_entry *h1
 835      = (struct elf_link_hash_entry *) ptr1;
 836   struct elf_link_hash_entry *h2
 837     = (struct elf_link_hash_entry *) ptr2;
 838
 839   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
 840 }
 841
 842 /* Find and/or create a hash entry for local symbol.  */
 843
 844 static struct elf_link_hash_entry *
 845 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
 846                                bfd *abfd, const Elf_Internal_Rela *rel,
 847                                bfd_boolean create)
 848 {
 849   struct elf_x86_64_link_hash_entry e, *ret;
 850   asection *sec = abfd->sections;
 851   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
 852                                        htab->r_sym (rel->r_info));
 853   void **slot;
 854
 855   e.elf.indx = sec->id;
 856   e.elf.dynstr_index = htab->r_sym (rel->r_info);
 857   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
 858                                    create ? INSERT : NO_INSERT);
 859
 860   if (!slot)
 861     return NULL;
 862
 863   if (*slot)
 864     {
 865       ret = (struct elf_x86_64_link_hash_entry *) *slot;
 866       return &ret->elf;
 867     }
 868
 869   ret = (struct elf_x86_64_link_hash_entry *)
 870         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
 871                         sizeof (struct elf_x86_64_link_hash_entry));
 872   if (ret)
 873     {
 874       memset (ret, 0, sizeof (*ret));
 875       ret->elf.indx = sec->id;
 876       ret->elf.dynstr_index = htab->r_sym (rel->r_info);
 877       ret->elf.dynindx = -1;
 878       *slot = ret;
 879     }
 880   return &ret->elf;
 881 }
 882
 883 /* Create an X86-64 ELF linker hash table.  */
 884
 885 static struct bfd_link_hash_table *
 886 elf_x86_64_link_hash_table_create (bfd *abfd)
 887 {
 888   struct elf_x86_64_link_hash_table *ret;
 889   bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
 890
 891   ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
 892   if (ret == NULL)
 893     return NULL;
 894
 895   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
 896                                       elf_x86_64_link_hash_newfunc,
 897                                       sizeof (struct elf_x86_64_link_hash_entry),
 898                                       X86_64_ELF_DATA))
 899     {
 900       free (ret);
 901       return NULL;
 902     }
 903
 904   ret->sdynbss = NULL;
 905   ret->srelbss = NULL;
 906   ret->plt_eh_frame = NULL;
 907   ret->sym_cache.abfd = NULL;
 908   ret->tlsdesc_plt = 0;
 909   ret->tlsdesc_got = 0;
 910   ret->tls_ld_got.refcount = 0;
 911   ret->sgotplt_jump_table_size = 0;
 912   ret->tls_module_base = NULL;
 913   ret->next_jump_slot_index = 0;
 914   ret->next_irelative_index = 0;
 915
 916   if (ABI_64_P (abfd))
 917     {
 918       ret->r_info = elf64_r_info;
 919       ret->r_sym = elf64_r_sym;
 920       ret->pointer_r_type = R_X86_64_64;
 921       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
 922       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
 923     }
 924   else
 925     {
 926       ret->r_info = elf32_r_info;
 927       ret->r_sym = elf32_r_sym;
 928       ret->pointer_r_type = R_X86_64_32;
 929       ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
 930       ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
 931     }
 932
 933   ret->loc_hash_table = htab_try_create (1024,
 934                                          elf_x86_64_local_htab_hash,
 935                                          elf_x86_64_local_htab_eq,
 936                                          NULL);
 937   ret->loc_hash_memory = objalloc_create ();
 938   if (!ret->loc_hash_table || !ret->loc_hash_memory)
 939     {
 940       free (ret);
 941       return NULL;
 942     }
 943
 944   return &ret->elf.root;
 945 }
 946
 947 /* Destroy an X86-64 ELF linker hash table.  */
 948
 949 static void
 950 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
 951 {
 952   struct elf_x86_64_link_hash_table *htab
 953     = (struct elf_x86_64_link_hash_table *) hash;
 954
 955   if (htab->loc_hash_table)
 956     htab_delete (htab->loc_hash_table);
 957   if (htab->loc_hash_memory)
 958     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
 959   _bfd_generic_link_hash_table_free (hash);
 960 }
 961
 962 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 963    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 964    hash table.  */
 965
 966 static bfd_boolean
 967 elf_x86_64_create_dynamic_sections (bfd *dynobj,
 968                                     struct bfd_link_info *info)
 969 {
 970   struct elf_x86_64_link_hash_table *htab;
 971
 972   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 973     return FALSE;
 974
 975   htab = elf_x86_64_hash_table (info);
 976   if (htab == NULL)
 977     return FALSE;
 978
 979   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
 980   if (!info->shared)
 981     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
 982
 983   if (!htab->sdynbss
 984       || (!info->shared && !htab->srelbss))
 985     abort ();
 986
 987   if (!info->no_ld_generated_unwind_info
 988       && htab->plt_eh_frame == NULL
 989       && htab->elf.splt != NULL)
 990     {
 991       flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
 992                         | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 993                         | SEC_LINKER_CREATED);
 994       htab->plt_eh_frame
 995         = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
 996       if (htab->plt_eh_frame == NULL
 997           || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
 998         return FALSE;
 999     }
1000   return TRUE;
1001 }
1002
1003 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1004
1005 static void
1006 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1007                                  struct elf_link_hash_entry *dir,
1008                                  struct elf_link_hash_entry *ind)
1009 {
1010   struct elf_x86_64_link_hash_entry *edir, *eind;
1011
1012   edir = (struct elf_x86_64_link_hash_entry *) dir;
1013   eind = (struct elf_x86_64_link_hash_entry *) ind;
1014
1015   if (eind->dyn_relocs != NULL)
1016     {
1017       if (edir->dyn_relocs != NULL)
1018         {
1019           struct elf_dyn_relocs **pp;
1020           struct elf_dyn_relocs *p;
1021
1022           /* Add reloc counts against the indirect sym to the direct sym
1023              list.  Merge any entries against the same section.  */
1024           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1025             {
1026               struct elf_dyn_relocs *q;
1027
1028               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1029                 if (q->sec == p->sec)
1030                   {
1031                     q->pc_count += p->pc_count;
1032                     q->count += p->count;
1033                     *pp = p->next;
1034                     break;
1035                   }
1036               if (q == NULL)
1037                 pp = &p->next;
1038             }
1039           *pp = edir->dyn_relocs;
1040         }
1041
1042       edir->dyn_relocs = eind->dyn_relocs;
1043       eind->dyn_relocs = NULL;
1044     }
1045
1046   if (ind->root.type == bfd_link_hash_indirect
1047       && dir->got.refcount <= 0)
1048     {
1049       edir->tls_type = eind->tls_type;
1050       eind->tls_type = GOT_UNKNOWN;
1051     }
1052
1053   if (ELIMINATE_COPY_RELOCS
1054       && ind->root.type != bfd_link_hash_indirect
1055       && dir->dynamic_adjusted)
1056     {
1057       /* If called to transfer flags for a weakdef during processing
1058          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1059          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1060       dir->ref_dynamic |= ind->ref_dynamic;
1061       dir->ref_regular |= ind->ref_regular;
1062       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1063       dir->needs_plt |= ind->needs_plt;
1064       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1065     }
1066   else
1067     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1068 }
1069
1070 static bfd_boolean
1071 elf64_x86_64_elf_object_p (bfd *abfd)
1072 {
1073   /* Set the right machine number for an x86-64 elf64 file.  */
1074   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1075   return TRUE;
1076 }
1077
1078 static bfd_boolean
1079 elf32_x86_64_elf_object_p (bfd *abfd)
1080 {
1081   /* Set the right machine number for an x86-64 elf32 file.  */
1082   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1083   return TRUE;
1084 }
1085
1086 /* Return TRUE if the TLS access code sequence support transition
1087    from R_TYPE.  */
1088
1089 static bfd_boolean
1090 elf_x86_64_check_tls_transition (bfd *abfd,
1091                                  struct bfd_link_info *info,
1092                                  asection *sec,
1093                                  bfd_byte *contents,
1094                                  Elf_Internal_Shdr *symtab_hdr,
1095                                  struct elf_link_hash_entry **sym_hashes,
1096                                  unsigned int r_type,
1097                                  const Elf_Internal_Rela *rel,
1098                                  const Elf_Internal_Rela *relend)
1099 {
1100   unsigned int val;
1101   unsigned long r_symndx;
1102   struct elf_link_hash_entry *h;
1103   bfd_vma offset;
1104   struct elf_x86_64_link_hash_table *htab;
1105
1106   /* Get the section contents.  */
1107   if (contents == NULL)
1108     {
1109       if (elf_section_data (sec)->this_hdr.contents != NULL)
1110         contents = elf_section_data (sec)->this_hdr.contents;
1111       else
1112         {
1113           /* FIXME: How to better handle error condition?  */
1114           if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1115             return FALSE;
1116
1117           /* Cache the section contents for elf_link_input_bfd.  */
1118           elf_section_data (sec)->this_hdr.contents = contents;
1119         }
1120     }
1121
1122   htab = elf_x86_64_hash_table (info);
1123   offset = rel->r_offset;
1124   switch (r_type)
1125     {
1126     case R_X86_64_TLSGD:
1127     case R_X86_64_TLSLD:
1128       if ((rel + 1) >= relend)
1129         return FALSE;
1130
1131       if (r_type == R_X86_64_TLSGD)
1132         {
1133           /* Check transition from GD access model.  For 64bit, only
1134                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1135                 .word 0x6666; rex64; call __tls_get_addr
1136              can transit to different access model.  For 32bit, only
1137                 leaq foo@tlsgd(%rip), %rdi
1138                 .word 0x6666; rex64; call __tls_get_addr
1139              can transit to different access model.  */
1140
1141           static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1142           static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1143
1144           if ((offset + 12) > sec->size
1145               || memcmp (contents + offset + 4, call, 4) != 0)
1146             return FALSE;
1147
1148           if (ABI_64_P (abfd))
1149             {
1150               if (offset < 4
1151                   || memcmp (contents + offset - 4, leaq, 4) != 0)
1152                 return FALSE;
1153             }
1154           else
1155             {
1156               if (offset < 3
1157                   || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1158                 return FALSE;
1159             }
1160         }
1161       else
1162         {
1163           /* Check transition from LD access model.  Only
1164                 leaq foo@tlsld(%rip), %rdi;
1165                 call __tls_get_addr
1166              can transit to different access model.  */
1167
1168           static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1169
1170           if (offset < 3 || (offset + 9) > sec->size)
1171             return FALSE;
1172
1173           if (memcmp (contents + offset - 3, lea, 3) != 0
1174               || 0xe8 != *(contents + offset + 4))
1175             return FALSE;
1176         }
1177
1178       r_symndx = htab->r_sym (rel[1].r_info);
1179       if (r_symndx < symtab_hdr->sh_info)
1180         return FALSE;
1181
1182       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1183       /* Use strncmp to check __tls_get_addr since __tls_get_addr
1184          may be versioned.  */
1185       return (h != NULL
1186               && h->root.root.string != NULL
1187               && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1188                   || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1189               && (strncmp (h->root.root.string,
1190                            "__tls_get_addr", 14) == 0));
1191
1192     case R_X86_64_GOTTPOFF:
1193       /* Check transition from IE access model:
1194                 mov foo@gottpoff(%rip), %reg
1195                 add foo@gottpoff(%rip), %reg
1196        */
1197
1198       /* Check REX prefix first.  */
1199       if (offset >= 3 && (offset + 4) <= sec->size)
1200         {
1201           val = bfd_get_8 (abfd, contents + offset - 3);
1202           if (val != 0x48 && val != 0x4c)
1203             {
1204               /* X32 may have 0x44 REX prefix or no REX prefix.  */
1205               if (ABI_64_P (abfd))
1206                 return FALSE;
1207             }
1208         }
1209       else
1210         {
1211           /* X32 may not have any REX prefix.  */
1212           if (ABI_64_P (abfd))
1213             return FALSE;
1214           if (offset < 2 || (offset + 3) > sec->size)
1215             return FALSE;
1216         }
1217
1218       val = bfd_get_8 (abfd, contents + offset - 2);
1219       if (val != 0x8b && val != 0x03)
1220         return FALSE;
1221
1222       val = bfd_get_8 (abfd, contents + offset - 1);
1223       return (val & 0xc7) == 5;
1224
1225     case R_X86_64_GOTPC32_TLSDESC:
1226       /* Check transition from GDesc access model:
1227                 leaq x@tlsdesc(%rip), %rax
1228
1229          Make sure it's a leaq adding rip to a 32-bit offset
1230          into any register, although it's probably almost always
1231          going to be rax.  */
1232
1233       if (offset < 3 || (offset + 4) > sec->size)
1234         return FALSE;
1235
1236       val = bfd_get_8 (abfd, contents + offset - 3);
1237       if ((val & 0xfb) != 0x48)
1238         return FALSE;
1239
1240       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1241         return FALSE;
1242
1243       val = bfd_get_8 (abfd, contents + offset - 1);
1244       return (val & 0xc7) == 0x05;
1245
1246     case R_X86_64_TLSDESC_CALL:
1247       /* Check transition from GDesc access model:
1248                 call *x@tlsdesc(%rax)
1249        */
1250       if (offset + 2 <= sec->size)
1251         {
1252           /* Make sure that it's a call *x@tlsdesc(%rax).  */
1253           static const unsigned char call[] = { 0xff, 0x10 };
1254           return memcmp (contents + offset, call, 2) == 0;
1255         }
1256
1257       return FALSE;
1258
1259     default:
1260       abort ();
1261     }
1262 }
1263
1264 /* Return TRUE if the TLS access transition is OK or no transition
1265    will be performed.  Update R_TYPE if there is a transition.  */
1266
1267 static bfd_boolean
1268 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1269                            asection *sec, bfd_byte *contents,
1270                            Elf_Internal_Shdr *symtab_hdr,
1271                            struct elf_link_hash_entry **sym_hashes,
1272                            unsigned int *r_type, int tls_type,
1273                            const Elf_Internal_Rela *rel,
1274                            const Elf_Internal_Rela *relend,
1275                            struct elf_link_hash_entry *h,
1276                            unsigned long r_symndx)
1277 {
1278   unsigned int from_type = *r_type;
1279   unsigned int to_type = from_type;
1280   bfd_boolean check = TRUE;
1281
1282   /* Skip TLS transition for functions.  */
1283   if (h != NULL
1284       && (h->type == STT_FUNC
1285           || h->type == STT_GNU_IFUNC))
1286     return TRUE;
1287
1288   switch (from_type)
1289     {
1290     case R_X86_64_TLSGD:
1291     case R_X86_64_GOTPC32_TLSDESC:
1292     case R_X86_64_TLSDESC_CALL:
1293     case R_X86_64_GOTTPOFF:
1294       if (info->executable)
1295         {
1296           if (h == NULL)
1297             to_type = R_X86_64_TPOFF32;
1298           else
1299             to_type = R_X86_64_GOTTPOFF;
1300         }
1301
1302       /* When we are called from elf_x86_64_relocate_section,
1303          CONTENTS isn't NULL and there may be additional transitions
1304          based on TLS_TYPE.  */
1305       if (contents != NULL)
1306         {
1307           unsigned int new_to_type = to_type;
1308
1309           if (info->executable
1310               && h != NULL
1311               && h->dynindx == -1
1312               && tls_type == GOT_TLS_IE)
1313             new_to_type = R_X86_64_TPOFF32;
1314
1315           if (to_type == R_X86_64_TLSGD
1316               || to_type == R_X86_64_GOTPC32_TLSDESC
1317               || to_type == R_X86_64_TLSDESC_CALL)
1318             {
1319               if (tls_type == GOT_TLS_IE)
1320                 new_to_type = R_X86_64_GOTTPOFF;
1321             }
1322
1323           /* We checked the transition before when we were called from
1324              elf_x86_64_check_relocs.  We only want to check the new
1325              transition which hasn't been checked before.  */
1326           check = new_to_type != to_type && from_type == to_type;
1327           to_type = new_to_type;
1328         }
1329
1330       break;
1331
1332     case R_X86_64_TLSLD:
1333       if (info->executable)
1334         to_type = R_X86_64_TPOFF32;
1335       break;
1336
1337     default:
1338       return TRUE;
1339     }
1340
1341   /* Return TRUE if there is no transition.  */
1342   if (from_type == to_type)
1343     return TRUE;
1344
1345   /* Check if the transition can be performed.  */
1346   if (check
1347       && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1348                                             symtab_hdr, sym_hashes,
1349                                             from_type, rel, relend))
1350     {
1351       reloc_howto_type *from, *to;
1352       const char *name;
1353
1354       from = elf_x86_64_rtype_to_howto (abfd, from_type);
1355       to = elf_x86_64_rtype_to_howto (abfd, to_type);
1356
1357       if (h)
1358         name = h->root.root.string;
1359       else
1360         {
1361           struct elf_x86_64_link_hash_table *htab;
1362
1363           htab = elf_x86_64_hash_table (info);
1364           if (htab == NULL)
1365             name = "*unknown*";
1366           else
1367             {
1368               Elf_Internal_Sym *isym;
1369
1370               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1371                                             abfd, r_symndx);
1372               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1373             }
1374         }
1375
1376       (*_bfd_error_handler)
1377         (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1378            "in section `%A' failed"),
1379          abfd, sec, from->name, to->name, name,
1380          (unsigned long) rel->r_offset);
1381       bfd_set_error (bfd_error_bad_value);
1382       return FALSE;
1383     }
1384
1385   *r_type = to_type;
1386   return TRUE;
1387 }
1388
1389 /* Look through the relocs for a section during the first phase, and
1390    calculate needed space in the global offset table, procedure
1391    linkage table, and dynamic reloc sections.  */
1392
1393 static bfd_boolean
1394 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1395                          asection *sec,
1396                          const Elf_Internal_Rela *relocs)
1397 {
1398   struct elf_x86_64_link_hash_table *htab;
1399   Elf_Internal_Shdr *symtab_hdr;
1400   struct elf_link_hash_entry **sym_hashes;
1401   const Elf_Internal_Rela *rel;
1402   const Elf_Internal_Rela *rel_end;
1403   asection *sreloc;
1404
1405   if (info->relocatable)
1406     return TRUE;
1407
1408   BFD_ASSERT (is_x86_64_elf (abfd));
1409
1410   htab = elf_x86_64_hash_table (info);
1411   if (htab == NULL)
1412     return FALSE;
1413
1414   symtab_hdr = &elf_symtab_hdr (abfd);
1415   sym_hashes = elf_sym_hashes (abfd);
1416
1417   sreloc = NULL;
1418
1419   rel_end = relocs + sec->reloc_count;
1420   for (rel = relocs; rel < rel_end; rel++)
1421     {
1422       unsigned int r_type;
1423       unsigned long r_symndx;
1424       struct elf_link_hash_entry *h;
1425       Elf_Internal_Sym *isym;
1426       const char *name;
1427       bfd_boolean size_reloc;
1428
1429       r_symndx = htab->r_sym (rel->r_info);
1430       r_type = ELF32_R_TYPE (rel->r_info);
1431
1432       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1433         {
1434           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1435                                  abfd, r_symndx);
1436           return FALSE;
1437         }
1438
1439       if (r_symndx < symtab_hdr->sh_info)
1440         {
1441           /* A local symbol.  */
1442           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1443                                         abfd, r_symndx);
1444           if (isym == NULL)
1445             return FALSE;
1446
1447           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1448           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1449             {
1450               h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1451                                                  TRUE);
1452               if (h == NULL)
1453                 return FALSE;
1454
1455               /* Fake a STT_GNU_IFUNC symbol.  */
1456               h->type = STT_GNU_IFUNC;
1457               h->def_regular = 1;
1458               h->ref_regular = 1;
1459               h->forced_local = 1;
1460               h->root.type = bfd_link_hash_defined;
1461             }
1462           else
1463             h = NULL;
1464         }
1465       else
1466         {
1467           isym = NULL;
1468           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1469           while (h->root.type == bfd_link_hash_indirect
1470                  || h->root.type == bfd_link_hash_warning)
1471             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1472         }
1473
1474       /* Check invalid x32 relocations.  */
1475       if (!ABI_64_P (abfd))
1476         switch (r_type)
1477           {
1478           default:
1479             break;
1480
1481           case R_X86_64_DTPOFF64:
1482           case R_X86_64_TPOFF64:
1483           case R_X86_64_PC64:
1484           case R_X86_64_GOTOFF64:
1485           case R_X86_64_GOT64:
1486           case R_X86_64_GOTPCREL64:
1487           case R_X86_64_GOTPC64:
1488           case R_X86_64_GOTPLT64:
1489           case R_X86_64_PLTOFF64:
1490               {
1491                 if (h)
1492                   name = h->root.root.string;
1493                 else
1494                   name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1495                                            NULL);
1496                 (*_bfd_error_handler)
1497                   (_("%B: relocation %s against symbol `%s' isn't "
1498                      "supported in x32 mode"), abfd,
1499                    x86_64_elf_howto_table[r_type].name, name);
1500                 bfd_set_error (bfd_error_bad_value);
1501                 return FALSE;
1502               }
1503             break;
1504           }
1505
1506       if (h != NULL)
1507         {
1508           /* Create the ifunc sections for static executables.  If we
1509              never see an indirect function symbol nor we are building
1510              a static executable, those sections will be empty and
1511              won't appear in output.  */
1512           switch (r_type)
1513             {
1514             default:
1515               break;
1516
1517             case R_X86_64_32S:
1518             case R_X86_64_32:
1519             case R_X86_64_64:
1520             case R_X86_64_PC32:
1521             case R_X86_64_PC64:
1522             case R_X86_64_PLT32:
1523             case R_X86_64_GOTPCREL:
1524             case R_X86_64_GOTPCREL64:
1525               if (htab->elf.dynobj == NULL)
1526                 htab->elf.dynobj = abfd;
1527               if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1528                 return FALSE;
1529               break;
1530             }
1531
1532           /* It is referenced by a non-shared object. */
1533           h->ref_regular = 1;
1534         }
1535
1536       if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1537                                        symtab_hdr, sym_hashes,
1538                                        &r_type, GOT_UNKNOWN,
1539                                        rel, rel_end, h, r_symndx))
1540         return FALSE;
1541
1542       switch (r_type)
1543         {
1544         case R_X86_64_TLSLD:
1545           htab->tls_ld_got.refcount += 1;
1546           goto create_got;
1547
1548         case R_X86_64_TPOFF32:
1549           if (!info->executable && ABI_64_P (abfd))
1550             {
1551               if (h)
1552                 name = h->root.root.string;
1553               else
1554                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1555                                          NULL);
1556               (*_bfd_error_handler)
1557                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1558                  abfd,
1559                  x86_64_elf_howto_table[r_type].name, name);
1560               bfd_set_error (bfd_error_bad_value);
1561               return FALSE;
1562             }
1563           break;
1564
1565         case R_X86_64_GOTTPOFF:
1566           if (!info->executable)
1567             info->flags |= DF_STATIC_TLS;
1568           /* Fall through */
1569
1570         case R_X86_64_GOT32:
1571         case R_X86_64_GOTPCREL:
1572         case R_X86_64_TLSGD:
1573         case R_X86_64_GOT64:
1574         case R_X86_64_GOTPCREL64:
1575         case R_X86_64_GOTPLT64:
1576         case R_X86_64_GOTPC32_TLSDESC:
1577         case R_X86_64_TLSDESC_CALL:
1578           /* This symbol requires a global offset table entry.  */
1579           {
1580             int tls_type, old_tls_type;
1581
1582             switch (r_type)
1583               {
1584               default: tls_type = GOT_NORMAL; break;
1585               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1586               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1587               case R_X86_64_GOTPC32_TLSDESC:
1588               case R_X86_64_TLSDESC_CALL:
1589                 tls_type = GOT_TLS_GDESC; break;
1590               }
1591
1592             if (h != NULL)
1593               {
1594                 if (r_type == R_X86_64_GOTPLT64)
1595                   {
1596                     /* This relocation indicates that we also need
1597                        a PLT entry, as this is a function.  We don't need
1598                        a PLT entry for local symbols.  */
1599                     h->needs_plt = 1;
1600                     h->plt.refcount += 1;
1601                   }
1602                 h->got.refcount += 1;
1603                 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1604               }
1605             else
1606               {
1607                 bfd_signed_vma *local_got_refcounts;
1608
1609                 /* This is a global offset table entry for a local symbol.  */
1610                 local_got_refcounts = elf_local_got_refcounts (abfd);
1611                 if (local_got_refcounts == NULL)
1612                   {
1613                     bfd_size_type size;
1614
1615                     size = symtab_hdr->sh_info;
1616                     size *= sizeof (bfd_signed_vma)
1617                       + sizeof (bfd_vma) + sizeof (char);
1618                     local_got_refcounts = ((bfd_signed_vma *)
1619                                            bfd_zalloc (abfd, size));
1620                     if (local_got_refcounts == NULL)
1621                       return FALSE;
1622                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1623                     elf_x86_64_local_tlsdesc_gotent (abfd)
1624                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1625                     elf_x86_64_local_got_tls_type (abfd)
1626                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1627                   }
1628                 local_got_refcounts[r_symndx] += 1;
1629                 old_tls_type
1630                   = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1631               }
1632
1633             /* If a TLS symbol is accessed using IE at least once,
1634                there is no point to use dynamic model for it.  */
1635             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1636                 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1637                     || tls_type != GOT_TLS_IE))
1638               {
1639                 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1640                   tls_type = old_tls_type;
1641                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1642                          && GOT_TLS_GD_ANY_P (tls_type))
1643                   tls_type |= old_tls_type;
1644                 else
1645                   {
1646                     if (h)
1647                       name = h->root.root.string;
1648                     else
1649                       name = bfd_elf_sym_name (abfd, symtab_hdr,
1650                                                isym, NULL);
1651                     (*_bfd_error_handler)
1652                       (_("%B: '%s' accessed both as normal and thread local symbol"),
1653                        abfd, name);
1654                     bfd_set_error (bfd_error_bad_value);
1655                     return FALSE;
1656                   }
1657               }
1658
1659             if (old_tls_type != tls_type)
1660               {
1661                 if (h != NULL)
1662                   elf_x86_64_hash_entry (h)->tls_type = tls_type;
1663                 else
1664                   elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1665               }
1666           }
1667           /* Fall through */
1668
1669         case R_X86_64_GOTOFF64:
1670         case R_X86_64_GOTPC32:
1671         case R_X86_64_GOTPC64:
1672         create_got:
1673           if (htab->elf.sgot == NULL)
1674             {
1675               if (htab->elf.dynobj == NULL)
1676                 htab->elf.dynobj = abfd;
1677               if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1678                                                 info))
1679                 return FALSE;
1680             }
1681           break;
1682
1683         case R_X86_64_PLT32:
1684           /* This symbol requires a procedure linkage table entry.  We
1685              actually build the entry in adjust_dynamic_symbol,
1686              because this might be a case of linking PIC code which is
1687              never referenced by a dynamic object, in which case we
1688              don't need to generate a procedure linkage table entry
1689              after all.  */
1690
1691           /* If this is a local symbol, we resolve it directly without
1692              creating a procedure linkage table entry.  */
1693           if (h == NULL)
1694             continue;
1695
1696           h->needs_plt = 1;
1697           h->plt.refcount += 1;
1698           break;
1699
1700         case R_X86_64_PLTOFF64:
1701           /* This tries to form the 'address' of a function relative
1702              to GOT.  For global symbols we need a PLT entry.  */
1703           if (h != NULL)
1704             {
1705               h->needs_plt = 1;
1706               h->plt.refcount += 1;
1707             }
1708           goto create_got;
1709
1710         case R_X86_64_SIZE32:
1711         case R_X86_64_SIZE64:
1712           size_reloc = TRUE;
1713           goto do_size;
1714
1715         case R_X86_64_32:
1716           if (!ABI_64_P (abfd))
1717             goto pointer;
1718         case R_X86_64_8:
1719         case R_X86_64_16:
1720         case R_X86_64_32S:
1721           /* Let's help debug shared library creation.  These relocs
1722              cannot be used in shared libs.  Don't error out for
1723              sections we don't care about, such as debug sections or
1724              non-constant sections.  */
1725           if (info->shared
1726               && (sec->flags & SEC_ALLOC) != 0
1727               && (sec->flags & SEC_READONLY) != 0)
1728             {
1729               if (h)
1730                 name = h->root.root.string;
1731               else
1732                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1733               (*_bfd_error_handler)
1734                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1735                  abfd, x86_64_elf_howto_table[r_type].name, name);
1736               bfd_set_error (bfd_error_bad_value);
1737               return FALSE;
1738             }
1739           /* Fall through.  */
1740
1741         case R_X86_64_PC8:
1742         case R_X86_64_PC16:
1743         case R_X86_64_PC32:
1744         case R_X86_64_PC64:
1745         case R_X86_64_64:
1746 pointer:
1747           if (h != NULL && info->executable)
1748             {
1749               /* If this reloc is in a read-only section, we might
1750                  need a copy reloc.  We can't check reliably at this
1751                  stage whether the section is read-only, as input
1752                  sections have not yet been mapped to output sections.
1753                  Tentatively set the flag for now, and correct in
1754                  adjust_dynamic_symbol.  */
1755               h->non_got_ref = 1;
1756
1757               /* We may need a .plt entry if the function this reloc
1758                  refers to is in a shared lib.  */
1759               h->plt.refcount += 1;
1760               if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1761                 h->pointer_equality_needed = 1;
1762             }
1763
1764           size_reloc = FALSE;
1765 do_size:
1766           /* If we are creating a shared library, and this is a reloc
1767              against a global symbol, or a non PC relative reloc
1768              against a local symbol, then we need to copy the reloc
1769              into the shared library.  However, if we are linking with
1770              -Bsymbolic, we do not need to copy a reloc against a
1771              global symbol which is defined in an object we are
1772              including in the link (i.e., DEF_REGULAR is set).  At
1773              this point we have not seen all the input files, so it is
1774              possible that DEF_REGULAR is not set now but will be set
1775              later (it is never cleared).  In case of a weak definition,
1776              DEF_REGULAR may be cleared later by a strong definition in
1777              a shared library.  We account for that possibility below by
1778              storing information in the relocs_copied field of the hash
1779              table entry.  A similar situation occurs when creating
1780              shared libraries and symbol visibility changes render the
1781              symbol local.
1782
1783              If on the other hand, we are creating an executable, we
1784              may need to keep relocations for symbols satisfied by a
1785              dynamic library if we manage to avoid copy relocs for the
1786              symbol.  */
1787           if ((info->shared
1788                && (sec->flags & SEC_ALLOC) != 0
1789                && (! IS_X86_64_PCREL_TYPE (r_type)
1790                    || (h != NULL
1791                        && (! SYMBOLIC_BIND (info, h)
1792                            || h->root.type == bfd_link_hash_defweak
1793                            || !h->def_regular))))
1794               || (ELIMINATE_COPY_RELOCS
1795                   && !info->shared
1796                   && (sec->flags & SEC_ALLOC) != 0
1797                   && h != NULL
1798                   && (h->root.type == bfd_link_hash_defweak
1799                       || !h->def_regular)))
1800             {
1801               struct elf_dyn_relocs *p;
1802               struct elf_dyn_relocs **head;
1803
1804               /* We must copy these reloc types into the output file.
1805                  Create a reloc section in dynobj and make room for
1806                  this reloc.  */
1807               if (sreloc == NULL)
1808                 {
1809                   if (htab->elf.dynobj == NULL)
1810                     htab->elf.dynobj = abfd;
1811
1812                   sreloc = _bfd_elf_make_dynamic_reloc_section
1813                     (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1814                      abfd, /*rela?*/ TRUE);
1815
1816                   if (sreloc == NULL)
1817                     return FALSE;
1818                 }
1819
1820               /* If this is a global symbol, we count the number of
1821                  relocations we need for this symbol.  */
1822               if (h != NULL)
1823                 {
1824                   head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1825                 }
1826               else
1827                 {
1828                   /* Track dynamic relocs needed for local syms too.
1829                      We really need local syms available to do this
1830                      easily.  Oh well.  */
1831                   asection *s;
1832                   void **vpp;
1833
1834                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1835                                                 abfd, r_symndx);
1836                   if (isym == NULL)
1837                     return FALSE;
1838
1839                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1840                   if (s == NULL)
1841                     s = sec;
1842
1843                   /* Beware of type punned pointers vs strict aliasing
1844                      rules.  */
1845                   vpp = &(elf_section_data (s)->local_dynrel);
1846                   head = (struct elf_dyn_relocs **)vpp;
1847                 }
1848
1849               p = *head;
1850               if (p == NULL || p->sec != sec)
1851                 {
1852                   bfd_size_type amt = sizeof *p;
1853
1854                   p = ((struct elf_dyn_relocs *)
1855                        bfd_alloc (htab->elf.dynobj, amt));
1856                   if (p == NULL)
1857                     return FALSE;
1858                   p->next = *head;
1859                   *head = p;
1860                   p->sec = sec;
1861                   p->count = 0;
1862                   p->pc_count = 0;
1863                 }
1864
1865               p->count += 1;
1866               /* Count size relocation as PC-relative relocation.  */
1867               if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
1868                 p->pc_count += 1;
1869             }
1870           break;
1871
1872           /* This relocation describes the C++ object vtable hierarchy.
1873              Reconstruct it for later use during GC.  */
1874         case R_X86_64_GNU_VTINHERIT:
1875           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1876             return FALSE;
1877           break;
1878
1879           /* This relocation describes which C++ vtable entries are actually
1880              used.  Record for later use during GC.  */
1881         case R_X86_64_GNU_VTENTRY:
1882           BFD_ASSERT (h != NULL);
1883           if (h != NULL
1884               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1885             return FALSE;
1886           break;
1887
1888         default:
1889           break;
1890         }
1891     }
1892
1893   return TRUE;
1894 }
1895
1896 /* Return the section that should be marked against GC for a given
1897    relocation.  */
1898
1899 static asection *
1900 elf_x86_64_gc_mark_hook (asection *sec,
1901                          struct bfd_link_info *info,
1902                          Elf_Internal_Rela *rel,
1903                          struct elf_link_hash_entry *h,
1904                          Elf_Internal_Sym *sym)
1905 {
1906   if (h != NULL)
1907     switch (ELF32_R_TYPE (rel->r_info))
1908       {
1909       case R_X86_64_GNU_VTINHERIT:
1910       case R_X86_64_GNU_VTENTRY:
1911         return NULL;
1912       }
1913
1914   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1915 }
1916
1917 /* Update the got entry reference counts for the section being removed.  */
1918
1919 static bfd_boolean
1920 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1921                           asection *sec,
1922                           const Elf_Internal_Rela *relocs)
1923 {
1924   struct elf_x86_64_link_hash_table *htab;
1925   Elf_Internal_Shdr *symtab_hdr;
1926   struct elf_link_hash_entry **sym_hashes;
1927   bfd_signed_vma *local_got_refcounts;
1928   const Elf_Internal_Rela *rel, *relend;
1929
1930   if (info->relocatable)
1931     return TRUE;
1932
1933   htab = elf_x86_64_hash_table (info);
1934   if (htab == NULL)
1935     return FALSE;
1936
1937   elf_section_data (sec)->local_dynrel = NULL;
1938
1939   symtab_hdr = &elf_symtab_hdr (abfd);
1940   sym_hashes = elf_sym_hashes (abfd);
1941   local_got_refcounts = elf_local_got_refcounts (abfd);
1942
1943   htab = elf_x86_64_hash_table (info);
1944   relend = relocs + sec->reloc_count;
1945   for (rel = relocs; rel < relend; rel++)
1946     {
1947       unsigned long r_symndx;
1948       unsigned int r_type;
1949       struct elf_link_hash_entry *h = NULL;
1950
1951       r_symndx = htab->r_sym (rel->r_info);
1952       if (r_symndx >= symtab_hdr->sh_info)
1953         {
1954           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1955           while (h->root.type == bfd_link_hash_indirect
1956                  || h->root.type == bfd_link_hash_warning)
1957             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1958         }
1959       else
1960         {
1961           /* A local symbol.  */
1962           Elf_Internal_Sym *isym;
1963
1964           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1965                                         abfd, r_symndx);
1966
1967           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1968           if (isym != NULL
1969               && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1970             {
1971               h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
1972               if (h == NULL)
1973                 abort ();
1974             }
1975         }
1976
1977       if (h)
1978         {
1979           struct elf_x86_64_link_hash_entry *eh;
1980           struct elf_dyn_relocs **pp;
1981           struct elf_dyn_relocs *p;
1982
1983           eh = (struct elf_x86_64_link_hash_entry *) h;
1984
1985           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1986             if (p->sec == sec)
1987               {
1988                 /* Everything must go for SEC.  */
1989                 *pp = p->next;
1990                 break;
1991               }
1992         }
1993
1994       r_type = ELF32_R_TYPE (rel->r_info);
1995       if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1996                                        symtab_hdr, sym_hashes,
1997                                        &r_type, GOT_UNKNOWN,
1998                                        rel, relend, h, r_symndx))
1999         return FALSE;
2000
2001       switch (r_type)
2002         {
2003         case R_X86_64_TLSLD:
2004           if (htab->tls_ld_got.refcount > 0)
2005             htab->tls_ld_got.refcount -= 1;
2006           break;
2007
2008         case R_X86_64_TLSGD:
2009         case R_X86_64_GOTPC32_TLSDESC:
2010         case R_X86_64_TLSDESC_CALL:
2011         case R_X86_64_GOTTPOFF:
2012         case R_X86_64_GOT32:
2013         case R_X86_64_GOTPCREL:
2014         case R_X86_64_GOT64:
2015         case R_X86_64_GOTPCREL64:
2016         case R_X86_64_GOTPLT64:
2017           if (h != NULL)
2018             {
2019               if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2020                 h->plt.refcount -= 1;
2021               if (h->got.refcount > 0)
2022                 h->got.refcount -= 1;
2023               if (h->type == STT_GNU_IFUNC)
2024                 {
2025                   if (h->plt.refcount > 0)
2026                     h->plt.refcount -= 1;
2027                 }
2028             }
2029           else if (local_got_refcounts != NULL)
2030             {
2031               if (local_got_refcounts[r_symndx] > 0)
2032                 local_got_refcounts[r_symndx] -= 1;
2033             }
2034           break;
2035
2036         case R_X86_64_8:
2037         case R_X86_64_16:
2038         case R_X86_64_32:
2039         case R_X86_64_64:
2040         case R_X86_64_32S:
2041         case R_X86_64_PC8:
2042         case R_X86_64_PC16:
2043         case R_X86_64_PC32:
2044         case R_X86_64_PC64:
2045         case R_X86_64_SIZE32:
2046         case R_X86_64_SIZE64:
2047           if (info->shared
2048               && (h == NULL || h->type != STT_GNU_IFUNC))
2049             break;
2050           /* Fall thru */
2051
2052         case R_X86_64_PLT32:
2053         case R_X86_64_PLTOFF64:
2054           if (h != NULL)
2055             {
2056               if (h->plt.refcount > 0)
2057                 h->plt.refcount -= 1;
2058             }
2059           break;
2060
2061         default:
2062           break;
2063         }
2064     }
2065
2066   return TRUE;
2067 }
2068
2069 /* Adjust a symbol defined by a dynamic object and referenced by a
2070    regular object.  The current definition is in some section of the
2071    dynamic object, but we're not including those sections.  We have to
2072    change the definition to something the rest of the link can
2073    understand.  */
2074
2075 static bfd_boolean
2076 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2077                                   struct elf_link_hash_entry *h)
2078 {
2079   struct elf_x86_64_link_hash_table *htab;
2080   asection *s;
2081   struct elf_x86_64_link_hash_entry *eh;
2082   struct elf_dyn_relocs *p;
2083
2084   /* STT_GNU_IFUNC symbol must go through PLT. */
2085   if (h->type == STT_GNU_IFUNC)
2086     {
2087       /* All local STT_GNU_IFUNC references must be treate as local
2088          calls via local PLT.  */
2089       if (h->ref_regular
2090           && SYMBOL_CALLS_LOCAL (info, h))
2091         {
2092           bfd_size_type pc_count = 0, count = 0;
2093           struct elf_dyn_relocs **pp;
2094
2095           eh = (struct elf_x86_64_link_hash_entry *) h;
2096           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2097             {
2098               pc_count += p->pc_count;
2099               p->count -= p->pc_count;
2100               p->pc_count = 0;
2101               count += p->count;
2102               if (p->count == 0)
2103                 *pp = p->next;
2104               else
2105                 pp = &p->next;
2106             }
2107
2108           if (pc_count || count)
2109             {
2110               h->needs_plt = 1;
2111               h->non_got_ref = 1;
2112               if (h->plt.refcount <= 0)
2113                 h->plt.refcount = 1;
2114               else
2115                 h->plt.refcount += 1;
2116             }
2117         }
2118
2119       if (h->plt.refcount <= 0)
2120         {
2121           h->plt.offset = (bfd_vma) -1;
2122           h->needs_plt = 0;
2123         }
2124       return TRUE;
2125     }
2126
2127   /* If this is a function, put it in the procedure linkage table.  We
2128      will fill in the contents of the procedure linkage table later,
2129      when we know the address of the .got section.  */
2130   if (h->type == STT_FUNC
2131       || h->needs_plt)
2132     {
2133       if (h->plt.refcount <= 0
2134           || SYMBOL_CALLS_LOCAL (info, h)
2135           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2136               && h->root.type == bfd_link_hash_undefweak))
2137         {
2138           /* This case can occur if we saw a PLT32 reloc in an input
2139              file, but the symbol was never referred to by a dynamic
2140              object, or if all references were garbage collected.  In
2141              such a case, we don't actually need to build a procedure
2142              linkage table, and we can just do a PC32 reloc instead.  */
2143           h->plt.offset = (bfd_vma) -1;
2144           h->needs_plt = 0;
2145         }
2146
2147       return TRUE;
2148     }
2149   else
2150     /* It's possible that we incorrectly decided a .plt reloc was
2151        needed for an R_X86_64_PC32 reloc to a non-function sym in
2152        check_relocs.  We can't decide accurately between function and
2153        non-function syms in check-relocs;  Objects loaded later in
2154        the link may change h->type.  So fix it now.  */
2155     h->plt.offset = (bfd_vma) -1;
2156
2157   /* If this is a weak symbol, and there is a real definition, the
2158      processor independent code will have arranged for us to see the
2159      real definition first, and we can just use the same value.  */
2160   if (h->u.weakdef != NULL)
2161     {
2162       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2163                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2164       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2165       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2166       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2167         h->non_got_ref = h->u.weakdef->non_got_ref;
2168       return TRUE;
2169     }
2170
2171   /* This is a reference to a symbol defined by a dynamic object which
2172      is not a function.  */
2173
2174   /* If we are creating a shared library, we must presume that the
2175      only references to the symbol are via the global offset table.
2176      For such cases we need not do anything here; the relocations will
2177      be handled correctly by relocate_section.  */
2178   if (info->shared)
2179     return TRUE;
2180
2181   /* If there are no references to this symbol that do not use the
2182      GOT, we don't need to generate a copy reloc.  */
2183   if (!h->non_got_ref)
2184     return TRUE;
2185
2186   /* If -z nocopyreloc was given, we won't generate them either.  */
2187   if (info->nocopyreloc)
2188     {
2189       h->non_got_ref = 0;
2190       return TRUE;
2191     }
2192
2193   if (ELIMINATE_COPY_RELOCS)
2194     {
2195       eh = (struct elf_x86_64_link_hash_entry *) h;
2196       for (p = eh->dyn_relocs; p != NULL; p = p->next)
2197         {
2198           s = p->sec->output_section;
2199           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2200             break;
2201         }
2202
2203       /* If we didn't find any dynamic relocs in read-only sections, then
2204          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2205       if (p == NULL)
2206         {
2207           h->non_got_ref = 0;
2208           return TRUE;
2209         }
2210     }
2211
2212   /* We must allocate the symbol in our .dynbss section, which will
2213      become part of the .bss section of the executable.  There will be
2214      an entry for this symbol in the .dynsym section.  The dynamic
2215      object will contain position independent code, so all references
2216      from the dynamic object to this symbol will go through the global
2217      offset table.  The dynamic linker will use the .dynsym entry to
2218      determine the address it must put in the global offset table, so
2219      both the dynamic object and the regular object will refer to the
2220      same memory location for the variable.  */
2221
2222   htab = elf_x86_64_hash_table (info);
2223   if (htab == NULL)
2224     return FALSE;
2225
2226   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2227      to copy the initial value out of the dynamic object and into the
2228      runtime process image.  */
2229   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2230     {
2231       const struct elf_backend_data *bed;
2232       bed = get_elf_backend_data (info->output_bfd);
2233       htab->srelbss->size += bed->s->sizeof_rela;
2234       h->needs_copy = 1;
2235     }
2236
2237   s = htab->sdynbss;
2238
2239   return _bfd_elf_adjust_dynamic_copy (h, s);
2240 }
2241
2242 /* Allocate space in .plt, .got and associated reloc sections for
2243    dynamic relocs.  */
2244
2245 static bfd_boolean
2246 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2247 {
2248   struct bfd_link_info *info;
2249   struct elf_x86_64_link_hash_table *htab;
2250   struct elf_x86_64_link_hash_entry *eh;
2251   struct elf_dyn_relocs *p;
2252   const struct elf_backend_data *bed;
2253   unsigned int plt_entry_size;
2254
2255   if (h->root.type == bfd_link_hash_indirect)
2256     return TRUE;
2257
2258   eh = (struct elf_x86_64_link_hash_entry *) h;
2259
2260   info = (struct bfd_link_info *) inf;
2261   htab = elf_x86_64_hash_table (info);
2262   if (htab == NULL)
2263     return FALSE;
2264   bed = get_elf_backend_data (info->output_bfd);
2265   plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2266
2267   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2268      here if it is defined and referenced in a non-shared object.  */
2269   if (h->type == STT_GNU_IFUNC
2270       && h->def_regular)
2271     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2272                                                &eh->dyn_relocs,
2273                                                plt_entry_size,
2274                                                GOT_ENTRY_SIZE);
2275   else if (htab->elf.dynamic_sections_created
2276            && h->plt.refcount > 0)
2277     {
2278       /* Make sure this symbol is output as a dynamic symbol.
2279          Undefined weak syms won't yet be marked as dynamic.  */
2280       if (h->dynindx == -1
2281           && !h->forced_local)
2282         {
2283           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2284             return FALSE;
2285         }
2286
2287       if (info->shared
2288           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2289         {
2290           asection *s = htab->elf.splt;
2291
2292           /* If this is the first .plt entry, make room for the special
2293              first entry.  */
2294           if (s->size == 0)
2295             s->size += plt_entry_size;
2296
2297           h->plt.offset = s->size;
2298
2299           /* If this symbol is not defined in a regular file, and we are
2300              not generating a shared library, then set the symbol to this
2301              location in the .plt.  This is required to make function
2302              pointers compare as equal between the normal executable and
2303              the shared library.  */
2304           if (! info->shared
2305               && !h->def_regular)
2306             {
2307               h->root.u.def.section = s;
2308               h->root.u.def.value = h->plt.offset;
2309             }
2310
2311           /* Make room for this entry.  */
2312           s->size += plt_entry_size;
2313
2314           /* We also need to make an entry in the .got.plt section, which
2315              will be placed in the .got section by the linker script.  */
2316           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2317
2318           /* We also need to make an entry in the .rela.plt section.  */
2319           htab->elf.srelplt->size += bed->s->sizeof_rela;
2320           htab->elf.srelplt->reloc_count++;
2321         }
2322       else
2323         {
2324           h->plt.offset = (bfd_vma) -1;
2325           h->needs_plt = 0;
2326         }
2327     }
2328   else
2329     {
2330       h->plt.offset = (bfd_vma) -1;
2331       h->needs_plt = 0;
2332     }
2333
2334   eh->tlsdesc_got = (bfd_vma) -1;
2335
2336   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2337      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
2338   if (h->got.refcount > 0
2339       && info->executable
2340       && h->dynindx == -1
2341       && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2342     {
2343       h->got.offset = (bfd_vma) -1;
2344     }
2345   else if (h->got.refcount > 0)
2346     {
2347       asection *s;
2348       bfd_boolean dyn;
2349       int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2350
2351       /* Make sure this symbol is output as a dynamic symbol.
2352          Undefined weak syms won't yet be marked as dynamic.  */
2353       if (h->dynindx == -1
2354           && !h->forced_local)
2355         {
2356           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2357             return FALSE;
2358         }
2359
2360       if (GOT_TLS_GDESC_P (tls_type))
2361         {
2362           eh->tlsdesc_got = htab->elf.sgotplt->size
2363             - elf_x86_64_compute_jump_table_size (htab);
2364           htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2365           h->got.offset = (bfd_vma) -2;
2366         }
2367       if (! GOT_TLS_GDESC_P (tls_type)
2368           || GOT_TLS_GD_P (tls_type))
2369         {
2370           s = htab->elf.sgot;
2371           h->got.offset = s->size;
2372           s->size += GOT_ENTRY_SIZE;
2373           if (GOT_TLS_GD_P (tls_type))
2374             s->size += GOT_ENTRY_SIZE;
2375         }
2376       dyn = htab->elf.dynamic_sections_created;
2377       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2378          and two if global.
2379          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
2380       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2381           || tls_type == GOT_TLS_IE)
2382         htab->elf.srelgot->size += bed->s->sizeof_rela;
2383       else if (GOT_TLS_GD_P (tls_type))
2384         htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2385       else if (! GOT_TLS_GDESC_P (tls_type)
2386                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2387                    || h->root.type != bfd_link_hash_undefweak)
2388                && (info->shared
2389                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2390         htab->elf.srelgot->size += bed->s->sizeof_rela;
2391       if (GOT_TLS_GDESC_P (tls_type))
2392         {
2393           htab->elf.srelplt->size += bed->s->sizeof_rela;
2394           htab->tlsdesc_plt = (bfd_vma) -1;
2395         }
2396     }
2397   else
2398     h->got.offset = (bfd_vma) -1;
2399
2400   if (eh->dyn_relocs == NULL)
2401     return TRUE;
2402
2403   /* In the shared -Bsymbolic case, discard space allocated for
2404      dynamic pc-relative relocs against symbols which turn out to be
2405      defined in regular objects.  For the normal shared case, discard
2406      space for pc-relative relocs that have become local due to symbol
2407      visibility changes.  */
2408
2409   if (info->shared)
2410     {
2411       /* Relocs that use pc_count are those that appear on a call
2412          insn, or certain REL relocs that can generated via assembly.
2413          We want calls to protected symbols to resolve directly to the
2414          function rather than going via the plt.  If people want
2415          function pointer comparisons to work as expected then they
2416          should avoid writing weird assembly.  */
2417       if (SYMBOL_CALLS_LOCAL (info, h))
2418         {
2419           struct elf_dyn_relocs **pp;
2420
2421           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2422             {
2423               p->count -= p->pc_count;
2424               p->pc_count = 0;
2425               if (p->count == 0)
2426                 *pp = p->next;
2427               else
2428                 pp = &p->next;
2429             }
2430         }
2431
2432       /* Also discard relocs on undefined weak syms with non-default
2433          visibility.  */
2434       if (eh->dyn_relocs != NULL
2435           && h->root.type == bfd_link_hash_undefweak)
2436         {
2437           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2438             eh->dyn_relocs = NULL;
2439
2440           /* Make sure undefined weak symbols are output as a dynamic
2441              symbol in PIEs.  */
2442           else if (h->dynindx == -1
2443                    && ! h->forced_local
2444                    && ! bfd_elf_link_record_dynamic_symbol (info, h))
2445             return FALSE;
2446         }
2447
2448     }
2449   else if (ELIMINATE_COPY_RELOCS)
2450     {
2451       /* For the non-shared case, discard space for relocs against
2452          symbols which turn out to need copy relocs or are not
2453          dynamic.  */
2454
2455       if (!h->non_got_ref
2456           && ((h->def_dynamic
2457                && !h->def_regular)
2458               || (htab->elf.dynamic_sections_created
2459                   && (h->root.type == bfd_link_hash_undefweak
2460                       || h->root.type == bfd_link_hash_undefined))))
2461         {
2462           /* Make sure this symbol is output as a dynamic symbol.
2463              Undefined weak syms won't yet be marked as dynamic.  */
2464           if (h->dynindx == -1
2465               && ! h->forced_local
2466               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2467             return FALSE;
2468
2469           /* If that succeeded, we know we'll be keeping all the
2470              relocs.  */
2471           if (h->dynindx != -1)
2472             goto keep;
2473         }
2474
2475       eh->dyn_relocs = NULL;
2476
2477     keep: ;
2478     }
2479
2480   /* Finally, allocate space.  */
2481   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2482     {
2483       asection * sreloc;
2484
2485       sreloc = elf_section_data (p->sec)->sreloc;
2486
2487       BFD_ASSERT (sreloc != NULL);
2488
2489       sreloc->size += p->count * bed->s->sizeof_rela;
2490     }
2491
2492   return TRUE;
2493 }
2494
2495 /* Allocate space in .plt, .got and associated reloc sections for
2496    local dynamic relocs.  */
2497
2498 static bfd_boolean
2499 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2500 {
2501   struct elf_link_hash_entry *h
2502     = (struct elf_link_hash_entry *) *slot;
2503
2504   if (h->type != STT_GNU_IFUNC
2505       || !h->def_regular
2506       || !h->ref_regular
2507       || !h->forced_local
2508       || h->root.type != bfd_link_hash_defined)
2509     abort ();
2510
2511   return elf_x86_64_allocate_dynrelocs (h, inf);
2512 }
2513
2514 /* Find any dynamic relocs that apply to read-only sections.  */
2515
2516 static bfd_boolean
2517 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2518                                void * inf)
2519 {
2520   struct elf_x86_64_link_hash_entry *eh;
2521   struct elf_dyn_relocs *p;
2522
2523   /* Skip local IFUNC symbols. */
2524   if (h->forced_local && h->type == STT_GNU_IFUNC)
2525     return TRUE;
2526
2527   eh = (struct elf_x86_64_link_hash_entry *) h;
2528   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2529     {
2530       asection *s = p->sec->output_section;
2531
2532       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2533         {
2534           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2535
2536           info->flags |= DF_TEXTREL;
2537
2538           if (info->warn_shared_textrel && info->shared)
2539             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2540                                     p->sec->owner, h->root.root.string,
2541                                     p->sec);
2542
2543           /* Not an error, just cut short the traversal.  */
2544           return FALSE;
2545         }
2546     }
2547   return TRUE;
2548 }
2549
2550 /* Convert
2551    mov foo@GOTPCREL(%rip), %reg
2552    to
2553    lea foo(%rip), %reg
2554    with the local symbol, foo.  */
2555
2556 static bfd_boolean
2557 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2558                                struct bfd_link_info *link_info)
2559 {
2560   Elf_Internal_Shdr *symtab_hdr;
2561   Elf_Internal_Rela *internal_relocs;
2562   Elf_Internal_Rela *irel, *irelend;
2563   bfd_byte *contents;
2564   struct elf_x86_64_link_hash_table *htab;
2565   bfd_boolean changed_contents;
2566   bfd_boolean changed_relocs;
2567   bfd_signed_vma *local_got_refcounts;
2568
2569   /* Don't even try to convert non-ELF outputs.  */
2570   if (!is_elf_hash_table (link_info->hash))
2571     return FALSE;
2572
2573   /* Nothing to do if there are no codes, no relocations or no output.  */
2574   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2575       || sec->reloc_count == 0
2576       || discarded_section (sec))
2577     return TRUE;
2578
2579   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2580
2581   /* Load the relocations for this section.  */
2582   internal_relocs = (_bfd_elf_link_read_relocs
2583                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2584                       link_info->keep_memory));
2585   if (internal_relocs == NULL)
2586     return FALSE;
2587
2588   htab = elf_x86_64_hash_table (link_info);
2589   changed_contents = FALSE;
2590   changed_relocs = FALSE;
2591   local_got_refcounts = elf_local_got_refcounts (abfd);
2592
2593   /* Get the section contents.  */
2594   if (elf_section_data (sec)->this_hdr.contents != NULL)
2595     contents = elf_section_data (sec)->this_hdr.contents;
2596   else
2597     {
2598       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2599         goto error_return;
2600     }
2601
2602   irelend = internal_relocs + sec->reloc_count;
2603   for (irel = internal_relocs; irel < irelend; irel++)
2604     {
2605       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2606       unsigned int r_symndx = htab->r_sym (irel->r_info);
2607       unsigned int indx;
2608       struct elf_link_hash_entry *h;
2609
2610       if (r_type != R_X86_64_GOTPCREL)
2611         continue;
2612
2613       /* Get the symbol referred to by the reloc.  */
2614       if (r_symndx < symtab_hdr->sh_info)
2615         {
2616           Elf_Internal_Sym *isym;
2617
2618           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2619                                         abfd, r_symndx);
2620
2621           /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation.  */
2622           if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2623               && bfd_get_8 (input_bfd,
2624                             contents + irel->r_offset - 2) == 0x8b)
2625             {
2626               bfd_put_8 (output_bfd, 0x8d,
2627                          contents + irel->r_offset - 2);
2628               irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2629               if (local_got_refcounts != NULL
2630                   && local_got_refcounts[r_symndx] > 0)
2631                 local_got_refcounts[r_symndx] -= 1;
2632               changed_contents = TRUE;
2633               changed_relocs = TRUE;
2634             }
2635           continue;
2636         }
2637
2638       indx = r_symndx - symtab_hdr->sh_info;
2639       h = elf_sym_hashes (abfd)[indx];
2640       BFD_ASSERT (h != NULL);
2641
2642       while (h->root.type == bfd_link_hash_indirect
2643              || h->root.type == bfd_link_hash_warning)
2644         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2645
2646       /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation.  We also
2647          avoid optimizing _DYNAMIC since ld.so may use its link-time
2648          address.  */
2649       if (h->def_regular
2650           && h->type != STT_GNU_IFUNC
2651           && h != htab->elf.hdynamic
2652           && SYMBOL_REFERENCES_LOCAL (link_info, h)
2653           && bfd_get_8 (input_bfd,
2654                         contents + irel->r_offset - 2) == 0x8b)
2655         {
2656           bfd_put_8 (output_bfd, 0x8d,
2657                      contents + irel->r_offset - 2);
2658           irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2659           if (h->got.refcount > 0)
2660             h->got.refcount -= 1;
2661           changed_contents = TRUE;
2662           changed_relocs = TRUE;
2663         }
2664     }
2665
2666   if (contents != NULL
2667       && elf_section_data (sec)->this_hdr.contents != contents)
2668     {
2669       if (!changed_contents && !link_info->keep_memory)
2670         free (contents);
2671       else
2672         {
2673           /* Cache the section contents for elf_link_input_bfd.  */
2674           elf_section_data (sec)->this_hdr.contents = contents;
2675         }
2676     }
2677
2678   if (elf_section_data (sec)->relocs != internal_relocs)
2679     {
2680       if (!changed_relocs)
2681         free (internal_relocs);
2682       else
2683         elf_section_data (sec)->relocs = internal_relocs;
2684     }
2685
2686   return TRUE;
2687
2688  error_return:
2689   if (contents != NULL
2690       && elf_section_data (sec)->this_hdr.contents != contents)
2691     free (contents);
2692   if (internal_relocs != NULL
2693       && elf_section_data (sec)->relocs != internal_relocs)
2694     free (internal_relocs);
2695   return FALSE;
2696 }
2697
2698 /* Set the sizes of the dynamic sections.  */
2699
2700 static bfd_boolean
2701 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2702                                   struct bfd_link_info *info)
2703 {
2704   struct elf_x86_64_link_hash_table *htab;
2705   bfd *dynobj;
2706   asection *s;
2707   bfd_boolean relocs;
2708   bfd *ibfd;
2709   const struct elf_backend_data *bed;
2710
2711   htab = elf_x86_64_hash_table (info);
2712   if (htab == NULL)
2713     return FALSE;
2714   bed = get_elf_backend_data (output_bfd);
2715
2716   dynobj = htab->elf.dynobj;
2717   if (dynobj == NULL)
2718     abort ();
2719
2720   if (htab->elf.dynamic_sections_created)
2721     {
2722       /* Set the contents of the .interp section to the interpreter.  */
2723       if (info->executable)
2724         {
2725           s = bfd_get_linker_section (dynobj, ".interp");
2726           if (s == NULL)
2727             abort ();
2728           s->size = htab->dynamic_interpreter_size;
2729           s->contents = (unsigned char *) htab->dynamic_interpreter;
2730         }
2731     }
2732
2733   /* Set up .got offsets for local syms, and space for local dynamic
2734      relocs.  */
2735   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2736     {
2737       bfd_signed_vma *local_got;
2738       bfd_signed_vma *end_local_got;
2739       char *local_tls_type;
2740       bfd_vma *local_tlsdesc_gotent;
2741       bfd_size_type locsymcount;
2742       Elf_Internal_Shdr *symtab_hdr;
2743       asection *srel;
2744
2745       if (! is_x86_64_elf (ibfd))
2746         continue;
2747
2748       for (s = ibfd->sections; s != NULL; s = s->next)
2749         {
2750           struct elf_dyn_relocs *p;
2751
2752           if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2753             return FALSE;
2754
2755           for (p = (struct elf_dyn_relocs *)
2756                     (elf_section_data (s)->local_dynrel);
2757                p != NULL;
2758                p = p->next)
2759             {
2760               if (!bfd_is_abs_section (p->sec)
2761                   && bfd_is_abs_section (p->sec->output_section))
2762                 {
2763                   /* Input section has been discarded, either because
2764                      it is a copy of a linkonce section or due to
2765                      linker script /DISCARD/, so we'll be discarding
2766                      the relocs too.  */
2767                 }
2768               else if (p->count != 0)
2769                 {
2770                   srel = elf_section_data (p->sec)->sreloc;
2771                   srel->size += p->count * bed->s->sizeof_rela;
2772                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2773                       && (info->flags & DF_TEXTREL) == 0)
2774                     {
2775                       info->flags |= DF_TEXTREL;
2776                       if (info->warn_shared_textrel && info->shared)
2777                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2778                                                 p->sec->owner, p->sec);
2779                     }
2780                 }
2781             }
2782         }
2783
2784       local_got = elf_local_got_refcounts (ibfd);
2785       if (!local_got)
2786         continue;
2787
2788       symtab_hdr = &elf_symtab_hdr (ibfd);
2789       locsymcount = symtab_hdr->sh_info;
2790       end_local_got = local_got + locsymcount;
2791       local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2792       local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2793       s = htab->elf.sgot;
2794       srel = htab->elf.srelgot;
2795       for (; local_got < end_local_got;
2796            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2797         {
2798           *local_tlsdesc_gotent = (bfd_vma) -1;
2799           if (*local_got > 0)
2800             {
2801               if (GOT_TLS_GDESC_P (*local_tls_type))
2802                 {
2803                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2804                     - elf_x86_64_compute_jump_table_size (htab);
2805                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2806                   *local_got = (bfd_vma) -2;
2807                 }
2808               if (! GOT_TLS_GDESC_P (*local_tls_type)
2809                   || GOT_TLS_GD_P (*local_tls_type))
2810                 {
2811                   *local_got = s->size;
2812                   s->size += GOT_ENTRY_SIZE;
2813                   if (GOT_TLS_GD_P (*local_tls_type))
2814                     s->size += GOT_ENTRY_SIZE;
2815                 }
2816               if (info->shared
2817                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2818                   || *local_tls_type == GOT_TLS_IE)
2819                 {
2820                   if (GOT_TLS_GDESC_P (*local_tls_type))
2821                     {
2822                       htab->elf.srelplt->size
2823                         += bed->s->sizeof_rela;
2824                       htab->tlsdesc_plt = (bfd_vma) -1;
2825                     }
2826                   if (! GOT_TLS_GDESC_P (*local_tls_type)
2827                       || GOT_TLS_GD_P (*local_tls_type))
2828                     srel->size += bed->s->sizeof_rela;
2829                 }
2830             }
2831           else
2832             *local_got = (bfd_vma) -1;
2833         }
2834     }
2835
2836   if (htab->tls_ld_got.refcount > 0)
2837     {
2838       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2839          relocs.  */
2840       htab->tls_ld_got.offset = htab->elf.sgot->size;
2841       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2842       htab->elf.srelgot->size += bed->s->sizeof_rela;
2843     }
2844   else
2845     htab->tls_ld_got.offset = -1;
2846
2847   /* Allocate global sym .plt and .got entries, and space for global
2848      sym dynamic relocs.  */
2849   elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2850                           info);
2851
2852   /* Allocate .plt and .got entries, and space for local symbols.  */
2853   htab_traverse (htab->loc_hash_table,
2854                  elf_x86_64_allocate_local_dynrelocs,
2855                  info);
2856
2857   /* For every jump slot reserved in the sgotplt, reloc_count is
2858      incremented.  However, when we reserve space for TLS descriptors,
2859      it's not incremented, so in order to compute the space reserved
2860      for them, it suffices to multiply the reloc count by the jump
2861      slot size.
2862
2863      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2864      so that R_X86_64_IRELATIVE entries come last.  */
2865   if (htab->elf.srelplt)
2866     {
2867       htab->sgotplt_jump_table_size
2868         = elf_x86_64_compute_jump_table_size (htab);
2869       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2870     }
2871   else if (htab->elf.irelplt)
2872     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2873
2874   if (htab->tlsdesc_plt)
2875     {
2876       /* If we're not using lazy TLS relocations, don't generate the
2877          PLT and GOT entries they require.  */
2878       if ((info->flags & DF_BIND_NOW))
2879         htab->tlsdesc_plt = 0;
2880       else
2881         {
2882           htab->tlsdesc_got = htab->elf.sgot->size;
2883           htab->elf.sgot->size += GOT_ENTRY_SIZE;
2884           /* Reserve room for the initial entry.
2885              FIXME: we could probably do away with it in this case.  */
2886           if (htab->elf.splt->size == 0)
2887             htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2888           htab->tlsdesc_plt = htab->elf.splt->size;
2889           htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2890         }
2891     }
2892
2893   if (htab->elf.sgotplt)
2894     {
2895       /* Don't allocate .got.plt section if there are no GOT nor PLT
2896          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2897       if ((htab->elf.hgot == NULL
2898            || !htab->elf.hgot->ref_regular_nonweak)
2899           && (htab->elf.sgotplt->size
2900               == get_elf_backend_data (output_bfd)->got_header_size)
2901           && (htab->elf.splt == NULL
2902               || htab->elf.splt->size == 0)
2903           && (htab->elf.sgot == NULL
2904               || htab->elf.sgot->size == 0)
2905           && (htab->elf.iplt == NULL
2906               || htab->elf.iplt->size == 0)
2907           && (htab->elf.igotplt == NULL
2908               || htab->elf.igotplt->size == 0))
2909         htab->elf.sgotplt->size = 0;
2910     }
2911
2912   if (htab->plt_eh_frame != NULL
2913       && htab->elf.splt != NULL
2914       && htab->elf.splt->size != 0
2915       && !bfd_is_abs_section (htab->elf.splt->output_section)
2916       && _bfd_elf_eh_frame_present (info))
2917     {
2918       const struct elf_x86_64_backend_data *arch_data
2919         = (const struct elf_x86_64_backend_data *) bed->arch_data;
2920       htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2921     }
2922
2923   /* We now have determined the sizes of the various dynamic sections.
2924      Allocate memory for them.  */
2925   relocs = FALSE;
2926   for (s = dynobj->sections; s != NULL; s = s->next)
2927     {
2928       if ((s->flags & SEC_LINKER_CREATED) == 0)
2929         continue;
2930
2931       if (s == htab->elf.splt
2932           || s == htab->elf.sgot
2933           || s == htab->elf.sgotplt
2934           || s == htab->elf.iplt
2935           || s == htab->elf.igotplt
2936           || s == htab->plt_eh_frame
2937           || s == htab->sdynbss)
2938         {
2939           /* Strip this section if we don't need it; see the
2940              comment below.  */
2941         }
2942       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2943         {
2944           if (s->size != 0 && s != htab->elf.srelplt)
2945             relocs = TRUE;
2946
2947           /* We use the reloc_count field as a counter if we need
2948              to copy relocs into the output file.  */
2949           if (s != htab->elf.srelplt)
2950             s->reloc_count = 0;
2951         }
2952       else
2953         {
2954           /* It's not one of our sections, so don't allocate space.  */
2955           continue;
2956         }
2957
2958       if (s->size == 0)
2959         {
2960           /* If we don't need this section, strip it from the
2961              output file.  This is mostly to handle .rela.bss and
2962              .rela.plt.  We must create both sections in
2963              create_dynamic_sections, because they must be created
2964              before the linker maps input sections to output
2965              sections.  The linker does that before
2966              adjust_dynamic_symbol is called, and it is that
2967              function which decides whether anything needs to go
2968              into these sections.  */
2969
2970           s->flags |= SEC_EXCLUDE;
2971           continue;
2972         }
2973
2974       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2975         continue;
2976
2977       /* Allocate memory for the section contents.  We use bfd_zalloc
2978          here in case unused entries are not reclaimed before the
2979          section's contents are written out.  This should not happen,
2980          but this way if it does, we get a R_X86_64_NONE reloc instead
2981          of garbage.  */
2982       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2983       if (s->contents == NULL)
2984         return FALSE;
2985     }
2986
2987   if (htab->plt_eh_frame != NULL
2988       && htab->plt_eh_frame->contents != NULL)
2989     {
2990       const struct elf_x86_64_backend_data *arch_data
2991         = (const struct elf_x86_64_backend_data *) bed->arch_data;
2992
2993       memcpy (htab->plt_eh_frame->contents,
2994               arch_data->eh_frame_plt, htab->plt_eh_frame->size);
2995       bfd_put_32 (dynobj, htab->elf.splt->size,
2996                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2997     }
2998
2999   if (htab->elf.dynamic_sections_created)
3000     {
3001       /* Add some entries to the .dynamic section.  We fill in the
3002          values later, in elf_x86_64_finish_dynamic_sections, but we
3003          must add the entries now so that we get the correct size for
3004          the .dynamic section.  The DT_DEBUG entry is filled in by the
3005          dynamic linker and used by the debugger.  */
3006 #define add_dynamic_entry(TAG, VAL) \
3007   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3008
3009       if (info->executable)
3010         {
3011           if (!add_dynamic_entry (DT_DEBUG, 0))
3012             return FALSE;
3013         }
3014
3015       if (htab->elf.splt->size != 0)
3016         {
3017           if (!add_dynamic_entry (DT_PLTGOT, 0)
3018               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3019               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3020               || !add_dynamic_entry (DT_JMPREL, 0))
3021             return FALSE;
3022
3023           if (htab->tlsdesc_plt
3024               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3025                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3026             return FALSE;
3027         }
3028
3029       if (relocs)
3030         {
3031           if (!add_dynamic_entry (DT_RELA, 0)
3032               || !add_dynamic_entry (DT_RELASZ, 0)
3033               || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3034             return FALSE;
3035
3036           /* If any dynamic relocs apply to a read-only section,
3037              then we need a DT_TEXTREL entry.  */
3038           if ((info->flags & DF_TEXTREL) == 0)
3039             elf_link_hash_traverse (&htab->elf,
3040                                     elf_x86_64_readonly_dynrelocs,
3041                                     info);
3042
3043           if ((info->flags & DF_TEXTREL) != 0)
3044             {
3045               if (!add_dynamic_entry (DT_TEXTREL, 0))
3046                 return FALSE;
3047             }
3048         }
3049     }
3050 #undef add_dynamic_entry
3051
3052   return TRUE;
3053 }
3054
3055 static bfd_boolean
3056 elf_x86_64_always_size_sections (bfd *output_bfd,
3057                                  struct bfd_link_info *info)
3058 {
3059   asection *tls_sec = elf_hash_table (info)->tls_sec;
3060
3061   if (tls_sec)
3062     {
3063       struct elf_link_hash_entry *tlsbase;
3064
3065       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3066                                       "_TLS_MODULE_BASE_",
3067                                       FALSE, FALSE, FALSE);
3068
3069       if (tlsbase && tlsbase->type == STT_TLS)
3070         {
3071           struct elf_x86_64_link_hash_table *htab;
3072           struct bfd_link_hash_entry *bh = NULL;
3073           const struct elf_backend_data *bed
3074             = get_elf_backend_data (output_bfd);
3075
3076           htab = elf_x86_64_hash_table (info);
3077           if (htab == NULL)
3078             return FALSE;
3079
3080           if (!(_bfd_generic_link_add_one_symbol
3081                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3082                  tls_sec, 0, NULL, FALSE,
3083                  bed->collect, &bh)))
3084             return FALSE;
3085
3086           htab->tls_module_base = bh;
3087
3088           tlsbase = (struct elf_link_hash_entry *)bh;
3089           tlsbase->def_regular = 1;
3090           tlsbase->other = STV_HIDDEN;
3091           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3092         }
3093     }
3094
3095   return TRUE;
3096 }
3097
3098 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3099    executables.  Rather than setting it to the beginning of the TLS
3100    section, we have to set it to the end.  This function may be called
3101    multiple times, it is idempotent.  */
3102
3103 static void
3104 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3105 {
3106   struct elf_x86_64_link_hash_table *htab;
3107   struct bfd_link_hash_entry *base;
3108
3109   if (!info->executable)
3110     return;
3111
3112   htab = elf_x86_64_hash_table (info);
3113   if (htab == NULL)
3114     return;
3115
3116   base = htab->tls_module_base;
3117   if (base == NULL)
3118     return;
3119
3120   base->u.def.value = htab->elf.tls_size;
3121 }
3122
3123 /* Return the base VMA address which should be subtracted from real addresses
3124    when resolving @dtpoff relocation.
3125    This is PT_TLS segment p_vaddr.  */
3126
3127 static bfd_vma
3128 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3129 {
3130   /* If tls_sec is NULL, we should have signalled an error already.  */
3131   if (elf_hash_table (info)->tls_sec == NULL)
3132     return 0;
3133   return elf_hash_table (info)->tls_sec->vma;
3134 }
3135
3136 /* Return the relocation value for @tpoff relocation
3137    if STT_TLS virtual address is ADDRESS.  */
3138
3139 static bfd_vma
3140 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3141 {
3142   struct elf_link_hash_table *htab = elf_hash_table (info);
3143   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3144   bfd_vma static_tls_size;
3145
3146   /* If tls_segment is NULL, we should have signalled an error already.  */
3147   if (htab->tls_sec == NULL)
3148     return 0;
3149
3150   /* Consider special static TLS alignment requirements.  */
3151   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3152   return address - static_tls_size - htab->tls_sec->vma;
3153 }
3154
3155 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3156    branch?  */
3157
3158 static bfd_boolean
3159 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3160 {
3161   /* Opcode             Instruction
3162      0xe8               call
3163      0xe9               jump
3164      0x0f 0x8x          conditional jump */
3165   return ((offset > 0
3166            && (contents [offset - 1] == 0xe8
3167                || contents [offset - 1] == 0xe9))
3168           || (offset > 1
3169               && contents [offset - 2] == 0x0f
3170               && (contents [offset - 1] & 0xf0) == 0x80));
3171 }
3172
3173 /* Relocate an x86_64 ELF section.  */
3174
3175 static bfd_boolean
3176 elf_x86_64_relocate_section (bfd *output_bfd,
3177                              struct bfd_link_info *info,
3178                              bfd *input_bfd,
3179                              asection *input_section,
3180                              bfd_byte *contents,
3181                              Elf_Internal_Rela *relocs,
3182                              Elf_Internal_Sym *local_syms,
3183                              asection **local_sections)
3184 {
3185   struct elf_x86_64_link_hash_table *htab;
3186   Elf_Internal_Shdr *symtab_hdr;
3187   struct elf_link_hash_entry **sym_hashes;
3188   bfd_vma *local_got_offsets;
3189   bfd_vma *local_tlsdesc_gotents;
3190   Elf_Internal_Rela *rel;
3191   Elf_Internal_Rela *relend;
3192   const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3193
3194   BFD_ASSERT (is_x86_64_elf (input_bfd));
3195
3196   htab = elf_x86_64_hash_table (info);
3197   if (htab == NULL)
3198     return FALSE;
3199   symtab_hdr = &elf_symtab_hdr (input_bfd);
3200   sym_hashes = elf_sym_hashes (input_bfd);
3201   local_got_offsets = elf_local_got_offsets (input_bfd);
3202   local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3203
3204   elf_x86_64_set_tls_module_base (info);
3205
3206   rel = relocs;
3207   relend = relocs + input_section->reloc_count;
3208   for (; rel < relend; rel++)
3209     {
3210       unsigned int r_type;
3211       reloc_howto_type *howto;
3212       unsigned long r_symndx;
3213       struct elf_link_hash_entry *h;
3214       Elf_Internal_Sym *sym;
3215       asection *sec;
3216       bfd_vma off, offplt;
3217       bfd_vma relocation;
3218       bfd_boolean unresolved_reloc;
3219       bfd_reloc_status_type r;
3220       int tls_type;
3221       asection *base_got;
3222       bfd_vma st_size;
3223
3224       r_type = ELF32_R_TYPE (rel->r_info);
3225       if (r_type == (int) R_X86_64_GNU_VTINHERIT
3226           || r_type == (int) R_X86_64_GNU_VTENTRY)
3227         continue;
3228
3229       if (r_type >= (int) R_X86_64_standard)
3230         {
3231           (*_bfd_error_handler)
3232             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3233              input_bfd, input_section, r_type);
3234           bfd_set_error (bfd_error_bad_value);
3235           return FALSE;
3236         }
3237
3238       if (r_type != (int) R_X86_64_32
3239           || ABI_64_P (output_bfd))
3240         howto = x86_64_elf_howto_table + r_type;
3241       else
3242         howto = (x86_64_elf_howto_table
3243                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3244       r_symndx = htab->r_sym (rel->r_info);
3245       h = NULL;
3246       sym = NULL;
3247       sec = NULL;
3248       unresolved_reloc = FALSE;
3249       if (r_symndx < symtab_hdr->sh_info)
3250         {
3251           sym = local_syms + r_symndx;
3252           sec = local_sections[r_symndx];
3253
3254           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3255                                                 &sec, rel);
3256           st_size = sym->st_size;
3257
3258           /* Relocate against local STT_GNU_IFUNC symbol.  */
3259           if (!info->relocatable
3260               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3261             {
3262               h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3263                                                  rel, FALSE);
3264               if (h == NULL)
3265                 abort ();
3266
3267               /* Set STT_GNU_IFUNC symbol value.  */
3268               h->root.u.def.value = sym->st_value;
3269               h->root.u.def.section = sec;
3270             }
3271         }
3272       else
3273         {
3274           bfd_boolean warned ATTRIBUTE_UNUSED;
3275
3276           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3277                                    r_symndx, symtab_hdr, sym_hashes,
3278                                    h, sec, relocation,
3279                                    unresolved_reloc, warned);
3280           st_size = h->size;
3281         }
3282
3283       if (sec != NULL && discarded_section (sec))
3284         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3285                                          rel, 1, relend, howto, 0, contents);
3286
3287       if (info->relocatable)
3288         continue;
3289
3290       if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3291         {
3292           if (r_type == R_X86_64_64)
3293             {
3294               /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3295                  zero-extend it to 64bit if addend is zero.  */
3296               r_type = R_X86_64_32;
3297               memset (contents + rel->r_offset + 4, 0, 4);
3298             }
3299           else if (r_type == R_X86_64_SIZE64)
3300             {
3301               /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3302                  zero-extend it to 64bit if addend is zero.  */
3303               r_type = R_X86_64_SIZE32;
3304               memset (contents + rel->r_offset + 4, 0, 4);
3305             }
3306         }
3307
3308       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3309          it here if it is defined in a non-shared object.  */
3310       if (h != NULL
3311           && h->type == STT_GNU_IFUNC
3312           && h->def_regular)
3313         {
3314           asection *plt;
3315           bfd_vma plt_index;
3316           const char *name;
3317
3318           if ((input_section->flags & SEC_ALLOC) == 0
3319               || h->plt.offset == (bfd_vma) -1)
3320             abort ();
3321
3322           /* STT_GNU_IFUNC symbol must go through PLT.  */
3323           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3324           relocation = (plt->output_section->vma
3325                         + plt->output_offset + h->plt.offset);
3326
3327           switch (r_type)
3328             {
3329             default:
3330               if (h->root.root.string)
3331                 name = h->root.root.string;
3332               else
3333                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3334                                          NULL);
3335               (*_bfd_error_handler)
3336                 (_("%B: relocation %s against STT_GNU_IFUNC "
3337                    "symbol `%s' isn't handled by %s"), input_bfd,
3338                  x86_64_elf_howto_table[r_type].name,
3339                  name, __FUNCTION__);
3340               bfd_set_error (bfd_error_bad_value);
3341               return FALSE;
3342
3343             case R_X86_64_32S:
3344               if (info->shared)
3345                 abort ();
3346               goto do_relocation;
3347
3348             case R_X86_64_32:
3349               if (ABI_64_P (output_bfd))
3350                 goto do_relocation;
3351               /* FALLTHROUGH */
3352             case R_X86_64_64:
3353               if (rel->r_addend != 0)
3354                 {
3355                   if (h->root.root.string)
3356                     name = h->root.root.string;
3357                   else
3358                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3359                                              sym, NULL);
3360                   (*_bfd_error_handler)
3361                     (_("%B: relocation %s against STT_GNU_IFUNC "
3362                        "symbol `%s' has non-zero addend: %d"),
3363                      input_bfd, x86_64_elf_howto_table[r_type].name,
3364                      name, rel->r_addend);
3365                   bfd_set_error (bfd_error_bad_value);
3366                   return FALSE;
3367                 }
3368
3369               /* Generate dynamic relcoation only when there is a
3370                  non-GOT reference in a shared object.  */
3371               if (info->shared && h->non_got_ref)
3372                 {
3373                   Elf_Internal_Rela outrel;
3374                   asection *sreloc;
3375
3376                   /* Need a dynamic relocation to get the real function
3377                      address.  */
3378                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3379                                                              info,
3380                                                              input_section,
3381                                                              rel->r_offset);
3382                   if (outrel.r_offset == (bfd_vma) -1
3383                       || outrel.r_offset == (bfd_vma) -2)
3384                     abort ();
3385
3386                   outrel.r_offset += (input_section->output_section->vma
3387                                       + input_section->output_offset);
3388
3389                   if (h->dynindx == -1
3390                       || h->forced_local
3391                       || info->executable)
3392                     {
3393                       /* This symbol is resolved locally.  */
3394                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3395                       outrel.r_addend = (h->root.u.def.value
3396                                          + h->root.u.def.section->output_section->vma
3397                                          + h->root.u.def.section->output_offset);
3398                     }
3399                   else
3400                     {
3401                       outrel.r_info = htab->r_info (h->dynindx, r_type);
3402                       outrel.r_addend = 0;
3403                     }
3404
3405                   sreloc = htab->elf.irelifunc;
3406                   elf_append_rela (output_bfd, sreloc, &outrel);
3407
3408                   /* If this reloc is against an external symbol, we
3409                      do not want to fiddle with the addend.  Otherwise,
3410                      we need to include the symbol value so that it
3411                      becomes an addend for the dynamic reloc.  For an
3412                      internal symbol, we have updated addend.  */
3413                   continue;
3414                 }
3415               /* FALLTHROUGH */
3416             case R_X86_64_PC32:
3417             case R_X86_64_PC64:
3418             case R_X86_64_PLT32:
3419               goto do_relocation;
3420
3421             case R_X86_64_GOTPCREL:
3422             case R_X86_64_GOTPCREL64:
3423               base_got = htab->elf.sgot;
3424               off = h->got.offset;
3425
3426               if (base_got == NULL)
3427                 abort ();
3428
3429               if (off == (bfd_vma) -1)
3430                 {
3431                   /* We can't use h->got.offset here to save state, or
3432                      even just remember the offset, as finish_dynamic_symbol
3433                      would use that as offset into .got.  */
3434
3435                   if (htab->elf.splt != NULL)
3436                     {
3437                       plt_index = h->plt.offset / plt_entry_size - 1;
3438                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
3439                       base_got = htab->elf.sgotplt;
3440                     }
3441                   else
3442                     {
3443                       plt_index = h->plt.offset / plt_entry_size;
3444                       off = plt_index * GOT_ENTRY_SIZE;
3445                       base_got = htab->elf.igotplt;
3446                     }
3447
3448                   if (h->dynindx == -1
3449                       || h->forced_local
3450                       || info->symbolic)
3451                     {
3452                       /* This references the local defitionion.  We must
3453                          initialize this entry in the global offset table.
3454                          Since the offset must always be a multiple of 8,
3455                          we use the least significant bit to record
3456                          whether we have initialized it already.
3457
3458                          When doing a dynamic link, we create a .rela.got
3459                          relocation entry to initialize the value.  This
3460                          is done in the finish_dynamic_symbol routine.   */
3461                       if ((off & 1) != 0)
3462                         off &= ~1;
3463                       else
3464                         {
3465                           bfd_put_64 (output_bfd, relocation,
3466                                       base_got->contents + off);
3467                           /* Note that this is harmless for the GOTPLT64
3468                              case, as -1 | 1 still is -1.  */
3469                           h->got.offset |= 1;
3470                         }
3471                     }
3472                 }
3473
3474               relocation = (base_got->output_section->vma
3475                             + base_got->output_offset + off);
3476
3477               goto do_relocation;
3478             }
3479         }
3480
3481       /* When generating a shared object, the relocations handled here are
3482          copied into the output file to be resolved at run time.  */
3483       switch (r_type)
3484         {
3485         case R_X86_64_GOT32:
3486         case R_X86_64_GOT64:
3487           /* Relocation is to the entry for this symbol in the global
3488              offset table.  */
3489         case R_X86_64_GOTPCREL:
3490         case R_X86_64_GOTPCREL64:
3491           /* Use global offset table entry as symbol value.  */
3492         case R_X86_64_GOTPLT64:
3493           /* This is the same as GOT64 for relocation purposes, but
3494              indicates the existence of a PLT entry.  The difficulty is,
3495              that we must calculate the GOT slot offset from the PLT
3496              offset, if this symbol got a PLT entry (it was global).
3497              Additionally if it's computed from the PLT entry, then that
3498              GOT offset is relative to .got.plt, not to .got.  */
3499           base_got = htab->elf.sgot;
3500
3501           if (htab->elf.sgot == NULL)
3502             abort ();
3503
3504           if (h != NULL)
3505             {
3506               bfd_boolean dyn;
3507
3508               off = h->got.offset;
3509               if (h->needs_plt
3510                   && h->plt.offset != (bfd_vma)-1
3511                   && off == (bfd_vma)-1)
3512                 {
3513                   /* We can't use h->got.offset here to save
3514                      state, or even just remember the offset, as
3515                      finish_dynamic_symbol would use that as offset into
3516                      .got.  */
3517                   bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3518                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
3519                   base_got = htab->elf.sgotplt;
3520                 }
3521
3522               dyn = htab->elf.dynamic_sections_created;
3523
3524               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3525                   || (info->shared
3526                       && SYMBOL_REFERENCES_LOCAL (info, h))
3527                   || (ELF_ST_VISIBILITY (h->other)
3528                       && h->root.type == bfd_link_hash_undefweak))
3529                 {
3530                   /* This is actually a static link, or it is a -Bsymbolic
3531                      link and the symbol is defined locally, or the symbol
3532                      was forced to be local because of a version file.  We
3533                      must initialize this entry in the global offset table.
3534                      Since the offset must always be a multiple of 8, we
3535                      use the least significant bit to record whether we
3536                      have initialized it already.
3537
3538                      When doing a dynamic link, we create a .rela.got
3539                      relocation entry to initialize the value.  This is
3540                      done in the finish_dynamic_symbol routine.  */
3541                   if ((off & 1) != 0)
3542                     off &= ~1;
3543                   else
3544                     {
3545                       bfd_put_64 (output_bfd, relocation,
3546                                   base_got->contents + off);
3547                       /* Note that this is harmless for the GOTPLT64 case,
3548                          as -1 | 1 still is -1.  */
3549                       h->got.offset |= 1;
3550                     }
3551                 }
3552               else
3553                 unresolved_reloc = FALSE;
3554             }
3555           else
3556             {
3557               if (local_got_offsets == NULL)
3558                 abort ();
3559
3560               off = local_got_offsets[r_symndx];
3561
3562               /* The offset must always be a multiple of 8.  We use
3563                  the least significant bit to record whether we have
3564                  already generated the necessary reloc.  */
3565               if ((off & 1) != 0)
3566                 off &= ~1;
3567               else
3568                 {
3569                   bfd_put_64 (output_bfd, relocation,
3570                               base_got->contents + off);
3571
3572                   if (info->shared)
3573                     {
3574                       asection *s;
3575                       Elf_Internal_Rela outrel;
3576
3577                       /* We need to generate a R_X86_64_RELATIVE reloc
3578                          for the dynamic linker.  */
3579                       s = htab->elf.srelgot;
3580                       if (s == NULL)
3581                         abort ();
3582
3583                       outrel.r_offset = (base_got->output_section->vma
3584                                          + base_got->output_offset
3585                                          + off);
3586                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3587                       outrel.r_addend = relocation;
3588                       elf_append_rela (output_bfd, s, &outrel);
3589                     }
3590
3591                   local_got_offsets[r_symndx] |= 1;
3592                 }
3593             }
3594
3595           if (off >= (bfd_vma) -2)
3596             abort ();
3597
3598           relocation = base_got->output_section->vma
3599                        + base_got->output_offset + off;
3600           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3601             relocation -= htab->elf.sgotplt->output_section->vma
3602                           - htab->elf.sgotplt->output_offset;
3603
3604           break;
3605
3606         case R_X86_64_GOTOFF64:
3607           /* Relocation is relative to the start of the global offset
3608              table.  */
3609
3610           /* Check to make sure it isn't a protected function symbol
3611              for shared library since it may not be local when used
3612              as function address.  */
3613           if (!info->executable
3614               && h
3615               && !SYMBOLIC_BIND (info, h)
3616               && h->def_regular
3617               && h->type == STT_FUNC
3618               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3619             {
3620               (*_bfd_error_handler)
3621                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3622                  input_bfd, h->root.root.string);
3623               bfd_set_error (bfd_error_bad_value);
3624               return FALSE;
3625             }
3626
3627           /* Note that sgot is not involved in this
3628              calculation.  We always want the start of .got.plt.  If we
3629              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3630              permitted by the ABI, we might have to change this
3631              calculation.  */
3632           relocation -= htab->elf.sgotplt->output_section->vma
3633                         + htab->elf.sgotplt->output_offset;
3634           break;
3635
3636         case R_X86_64_GOTPC32:
3637         case R_X86_64_GOTPC64:
3638           /* Use global offset table as symbol value.  */
3639           relocation = htab->elf.sgotplt->output_section->vma
3640                        + htab->elf.sgotplt->output_offset;
3641           unresolved_reloc = FALSE;
3642           break;
3643
3644         case R_X86_64_PLTOFF64:
3645           /* Relocation is PLT entry relative to GOT.  For local
3646              symbols it's the symbol itself relative to GOT.  */
3647           if (h != NULL
3648               /* See PLT32 handling.  */
3649               && h->plt.offset != (bfd_vma) -1
3650               && htab->elf.splt != NULL)
3651             {
3652               relocation = (htab->elf.splt->output_section->vma
3653                             + htab->elf.splt->output_offset
3654                             + h->plt.offset);
3655               unresolved_reloc = FALSE;
3656             }
3657
3658           relocation -= htab->elf.sgotplt->output_section->vma
3659                         + htab->elf.sgotplt->output_offset;
3660           break;
3661
3662         case R_X86_64_PLT32:
3663           /* Relocation is to the entry for this symbol in the
3664              procedure linkage table.  */
3665
3666           /* Resolve a PLT32 reloc against a local symbol directly,
3667              without using the procedure linkage table.  */
3668           if (h == NULL)
3669             break;
3670
3671           if (h->plt.offset == (bfd_vma) -1
3672               || htab->elf.splt == NULL)
3673             {
3674               /* We didn't make a PLT entry for this symbol.  This
3675                  happens when statically linking PIC code, or when
3676                  using -Bsymbolic.  */
3677               break;
3678             }
3679
3680           relocation = (htab->elf.splt->output_section->vma
3681                         + htab->elf.splt->output_offset
3682                         + h->plt.offset);
3683           unresolved_reloc = FALSE;
3684           break;
3685
3686         case R_X86_64_SIZE32:
3687         case R_X86_64_SIZE64:
3688           /* Set to symbol size.  */
3689           relocation = st_size;
3690           goto direct;
3691
3692         case R_X86_64_PC8:
3693         case R_X86_64_PC16:
3694         case R_X86_64_PC32:
3695           if (info->shared
3696               && (input_section->flags & SEC_ALLOC) != 0
3697               && (input_section->flags & SEC_READONLY) != 0
3698               && h != NULL)
3699             {
3700               bfd_boolean fail = FALSE;
3701               bfd_boolean branch
3702                 = (r_type == R_X86_64_PC32
3703                    && is_32bit_relative_branch (contents, rel->r_offset));
3704
3705               if (SYMBOL_REFERENCES_LOCAL (info, h))
3706                 {
3707                   /* Symbol is referenced locally.  Make sure it is
3708                      defined locally or for a branch.  */
3709                   fail = !h->def_regular && !branch;
3710                 }
3711               else
3712                 {
3713                   /* Symbol isn't referenced locally.  We only allow
3714                      branch to symbol with non-default visibility. */
3715                   fail = (!branch
3716                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3717                 }
3718
3719               if (fail)
3720                 {
3721                   const char *fmt;
3722                   const char *v;
3723                   const char *pic = "";
3724
3725                   switch (ELF_ST_VISIBILITY (h->other))
3726                     {
3727                     case STV_HIDDEN:
3728                       v = _("hidden symbol");
3729                       break;
3730                     case STV_INTERNAL:
3731                       v = _("internal symbol");
3732                       break;
3733                     case STV_PROTECTED:
3734                       v = _("protected symbol");
3735                       break;
3736                     default:
3737                       v = _("symbol");
3738                       pic = _("; recompile with -fPIC");
3739                       break;
3740                     }
3741
3742                   if (h->def_regular)
3743                     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3744                   else
3745                     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3746
3747                   (*_bfd_error_handler) (fmt, input_bfd,
3748                                          x86_64_elf_howto_table[r_type].name,
3749                                          v,  h->root.root.string, pic);
3750                   bfd_set_error (bfd_error_bad_value);
3751                   return FALSE;
3752                 }
3753             }
3754           /* Fall through.  */
3755
3756         case R_X86_64_8:
3757         case R_X86_64_16:
3758         case R_X86_64_32:
3759         case R_X86_64_PC64:
3760         case R_X86_64_64:
3761           /* FIXME: The ABI says the linker should make sure the value is
3762              the same when it's zeroextended to 64 bit.  */
3763
3764 direct:
3765           if ((input_section->flags & SEC_ALLOC) == 0)
3766             break;
3767
3768           if ((info->shared
3769                && (h == NULL
3770                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3771                    || h->root.type != bfd_link_hash_undefweak)
3772                && ((! IS_X86_64_PCREL_TYPE (r_type)
3773                       && r_type != R_X86_64_SIZE32
3774                       && r_type != R_X86_64_SIZE64)
3775                    || ! SYMBOL_CALLS_LOCAL (info, h)))
3776               || (ELIMINATE_COPY_RELOCS
3777                   && !info->shared
3778                   && h != NULL
3779                   && h->dynindx != -1
3780                   && !h->non_got_ref
3781                   && ((h->def_dynamic
3782                        && !h->def_regular)
3783                       || h->root.type == bfd_link_hash_undefweak
3784                       || h->root.type == bfd_link_hash_undefined)))
3785             {
3786               Elf_Internal_Rela outrel;
3787               bfd_boolean skip, relocate;
3788               asection *sreloc;
3789
3790               /* When generating a shared object, these relocations
3791                  are copied into the output file to be resolved at run
3792                  time.  */
3793               skip = FALSE;
3794               relocate = FALSE;
3795
3796               outrel.r_offset =
3797                 _bfd_elf_section_offset (output_bfd, info, input_section,
3798                                          rel->r_offset);
3799               if (outrel.r_offset == (bfd_vma) -1)
3800                 skip = TRUE;
3801               else if (outrel.r_offset == (bfd_vma) -2)
3802                 skip = TRUE, relocate = TRUE;
3803
3804               outrel.r_offset += (input_section->output_section->vma
3805                                   + input_section->output_offset);
3806
3807               if (skip)
3808                 memset (&outrel, 0, sizeof outrel);
3809
3810               /* h->dynindx may be -1 if this symbol was marked to
3811                  become local.  */
3812               else if (h != NULL
3813                        && h->dynindx != -1
3814                        && (IS_X86_64_PCREL_TYPE (r_type)
3815                            || ! info->shared
3816                            || ! SYMBOLIC_BIND (info, h)
3817                            || ! h->def_regular))
3818                 {
3819                   outrel.r_info = htab->r_info (h->dynindx, r_type);
3820                   outrel.r_addend = rel->r_addend;
3821                 }
3822               else
3823                 {
3824                   /* This symbol is local, or marked to become local.  */
3825                   if (r_type == htab->pointer_r_type)
3826                     {
3827                       relocate = TRUE;
3828                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3829                       outrel.r_addend = relocation + rel->r_addend;
3830                     }
3831                   else if (r_type == R_X86_64_64
3832                            && !ABI_64_P (output_bfd))
3833                     {
3834                       relocate = TRUE;
3835                       outrel.r_info = htab->r_info (0,
3836                                                     R_X86_64_RELATIVE64);
3837                       outrel.r_addend = relocation + rel->r_addend;
3838                       /* Check addend overflow.  */
3839                       if ((outrel.r_addend & 0x80000000)
3840                           != (rel->r_addend & 0x80000000))
3841                         {
3842                           const char *name;
3843                           int addend = rel->r_addend;
3844                           if (h && h->root.root.string)
3845                             name = h->root.root.string;
3846                           else
3847                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3848                                                      sym, NULL);
3849                           if (addend < 0)
3850                             (*_bfd_error_handler)
3851                               (_("%B: addend -0x%x in relocation %s against "
3852                                  "symbol `%s' at 0x%lx in section `%A' is "
3853                                  "out of range"),
3854                                input_bfd, input_section, addend,
3855                                x86_64_elf_howto_table[r_type].name,
3856                                name, (unsigned long) rel->r_offset);
3857                           else
3858                             (*_bfd_error_handler)
3859                               (_("%B: addend 0x%x in relocation %s against "
3860                                  "symbol `%s' at 0x%lx in section `%A' is "
3861                                  "out of range"),
3862                                input_bfd, input_section, addend,
3863                                x86_64_elf_howto_table[r_type].name,
3864                                name, (unsigned long) rel->r_offset);
3865                           bfd_set_error (bfd_error_bad_value);
3866                           return FALSE;
3867                         }
3868                     }
3869                   else
3870                     {
3871                       long sindx;
3872
3873                       if (bfd_is_abs_section (sec))
3874                         sindx = 0;
3875                       else if (sec == NULL || sec->owner == NULL)
3876                         {
3877                           bfd_set_error (bfd_error_bad_value);
3878                           return FALSE;
3879                         }
3880                       else
3881                         {
3882                           asection *osec;
3883
3884                           /* We are turning this relocation into one
3885                              against a section symbol.  It would be
3886                              proper to subtract the symbol's value,
3887                              osec->vma, from the emitted reloc addend,
3888                              but ld.so expects buggy relocs.  */
3889                           osec = sec->output_section;
3890                           sindx = elf_section_data (osec)->dynindx;
3891                           if (sindx == 0)
3892                             {
3893                               asection *oi = htab->elf.text_index_section;
3894                               sindx = elf_section_data (oi)->dynindx;
3895                             }
3896                           BFD_ASSERT (sindx != 0);
3897                         }
3898
3899                       outrel.r_info = htab->r_info (sindx, r_type);
3900                       outrel.r_addend = relocation + rel->r_addend;
3901                     }
3902                 }
3903
3904               sreloc = elf_section_data (input_section)->sreloc;
3905
3906               if (sreloc == NULL || sreloc->contents == NULL)
3907                 {
3908                   r = bfd_reloc_notsupported;
3909                   goto check_relocation_error;
3910                 }
3911
3912               elf_append_rela (output_bfd, sreloc, &outrel);
3913
3914               /* If this reloc is against an external symbol, we do
3915                  not want to fiddle with the addend.  Otherwise, we
3916                  need to include the symbol value so that it becomes
3917                  an addend for the dynamic reloc.  */
3918               if (! relocate)
3919                 continue;
3920             }
3921
3922           break;
3923
3924         case R_X86_64_TLSGD:
3925         case R_X86_64_GOTPC32_TLSDESC:
3926         case R_X86_64_TLSDESC_CALL:
3927         case R_X86_64_GOTTPOFF:
3928           tls_type = GOT_UNKNOWN;
3929           if (h == NULL && local_got_offsets)
3930             tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3931           else if (h != NULL)
3932             tls_type = elf_x86_64_hash_entry (h)->tls_type;
3933
3934           if (! elf_x86_64_tls_transition (info, input_bfd,
3935                                            input_section, contents,
3936                                            symtab_hdr, sym_hashes,
3937                                            &r_type, tls_type, rel,
3938                                            relend, h, r_symndx))
3939             return FALSE;
3940
3941           if (r_type == R_X86_64_TPOFF32)
3942             {
3943               bfd_vma roff = rel->r_offset;
3944
3945               BFD_ASSERT (! unresolved_reloc);
3946
3947               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3948                 {
3949                   /* GD->LE transition.  For 64bit, change
3950                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3951                      .word 0x6666; rex64; call __tls_get_addr
3952                      into:
3953                      movq %fs:0, %rax
3954                      leaq foo@tpoff(%rax), %rax
3955                      For 32bit, change
3956                      leaq foo@tlsgd(%rip), %rdi
3957                      .word 0x6666; rex64; call __tls_get_addr
3958                      into:
3959                      movl %fs:0, %eax
3960                      leaq foo@tpoff(%rax), %rax */
3961                   if (ABI_64_P (output_bfd))
3962                     memcpy (contents + roff - 4,
3963                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3964                             16);
3965                   else
3966                     memcpy (contents + roff - 3,
3967                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3968                             15);
3969                   bfd_put_32 (output_bfd,
3970                               elf_x86_64_tpoff (info, relocation),
3971                               contents + roff + 8);
3972                   /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3973                   rel++;
3974                   continue;
3975                 }
3976               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3977                 {
3978                   /* GDesc -> LE transition.
3979                      It's originally something like:
3980                      leaq x@tlsdesc(%rip), %rax
3981
3982                      Change it to:
3983                      movl $x@tpoff, %rax.  */
3984
3985                   unsigned int val, type;
3986
3987                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3988                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3989                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3990                              contents + roff - 3);
3991                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3992                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3993                              contents + roff - 1);
3994                   bfd_put_32 (output_bfd,
3995                               elf_x86_64_tpoff (info, relocation),
3996                               contents + roff);
3997                   continue;
3998                 }
3999               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4000                 {
4001                   /* GDesc -> LE transition.
4002                      It's originally:
4003                      call *(%rax)
4004                      Turn it into:
4005                      xchg %ax,%ax.  */
4006                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4007                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4008                   continue;
4009                 }
4010               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4011                 {
4012                   /* IE->LE transition:
4013                      Originally it can be one of:
4014                      movq foo@gottpoff(%rip), %reg
4015                      addq foo@gottpoff(%rip), %reg
4016                      We change it into:
4017                      movq $foo, %reg
4018                      leaq foo(%reg), %reg
4019                      addq $foo, %reg.  */
4020
4021                   unsigned int val, type, reg;
4022
4023                   val = bfd_get_8 (input_bfd, contents + roff - 3);
4024                   type = bfd_get_8 (input_bfd, contents + roff - 2);
4025                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
4026                   reg >>= 3;
4027                   if (type == 0x8b)
4028                     {
4029                       /* movq */
4030                       if (val == 0x4c)
4031                         bfd_put_8 (output_bfd, 0x49,
4032                                    contents + roff - 3);
4033                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4034                         bfd_put_8 (output_bfd, 0x41,
4035                                    contents + roff - 3);
4036                       bfd_put_8 (output_bfd, 0xc7,
4037                                  contents + roff - 2);
4038                       bfd_put_8 (output_bfd, 0xc0 | reg,
4039                                  contents + roff - 1);
4040                     }
4041                   else if (reg == 4)
4042                     {
4043                       /* addq -> addq - addressing with %rsp/%r12 is
4044                          special  */
4045                       if (val == 0x4c)
4046                         bfd_put_8 (output_bfd, 0x49,
4047                                    contents + roff - 3);
4048                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4049                         bfd_put_8 (output_bfd, 0x41,
4050                                    contents + roff - 3);
4051                       bfd_put_8 (output_bfd, 0x81,
4052                                  contents + roff - 2);
4053                       bfd_put_8 (output_bfd, 0xc0 | reg,
4054                                  contents + roff - 1);
4055                     }
4056                   else
4057                     {
4058                       /* addq -> leaq */
4059                       if (val == 0x4c)
4060                         bfd_put_8 (output_bfd, 0x4d,
4061                                    contents + roff - 3);
4062                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4063                         bfd_put_8 (output_bfd, 0x45,
4064                                    contents + roff - 3);
4065                       bfd_put_8 (output_bfd, 0x8d,
4066                                  contents + roff - 2);
4067                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4068                                  contents + roff - 1);
4069                     }
4070                   bfd_put_32 (output_bfd,
4071                               elf_x86_64_tpoff (info, relocation),
4072                               contents + roff);
4073                   continue;
4074                 }
4075               else
4076                 BFD_ASSERT (FALSE);
4077             }
4078
4079           if (htab->elf.sgot == NULL)
4080             abort ();
4081
4082           if (h != NULL)
4083             {
4084               off = h->got.offset;
4085               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4086             }
4087           else
4088             {
4089               if (local_got_offsets == NULL)
4090                 abort ();
4091
4092               off = local_got_offsets[r_symndx];
4093               offplt = local_tlsdesc_gotents[r_symndx];
4094             }
4095
4096           if ((off & 1) != 0)
4097             off &= ~1;
4098           else
4099             {
4100               Elf_Internal_Rela outrel;
4101               int dr_type, indx;
4102               asection *sreloc;
4103
4104               if (htab->elf.srelgot == NULL)
4105                 abort ();
4106
4107               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4108
4109               if (GOT_TLS_GDESC_P (tls_type))
4110                 {
4111                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4112                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4113                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4114                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4115                                      + htab->elf.sgotplt->output_offset
4116                                      + offplt
4117                                      + htab->sgotplt_jump_table_size);
4118                   sreloc = htab->elf.srelplt;
4119                   if (indx == 0)
4120                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4121                   else
4122                     outrel.r_addend = 0;
4123                   elf_append_rela (output_bfd, sreloc, &outrel);
4124                 }
4125
4126               sreloc = htab->elf.srelgot;
4127
4128               outrel.r_offset = (htab->elf.sgot->output_section->vma
4129                                  + htab->elf.sgot->output_offset + off);
4130
4131               if (GOT_TLS_GD_P (tls_type))
4132                 dr_type = R_X86_64_DTPMOD64;
4133               else if (GOT_TLS_GDESC_P (tls_type))
4134                 goto dr_done;
4135               else
4136                 dr_type = R_X86_64_TPOFF64;
4137
4138               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4139               outrel.r_addend = 0;
4140               if ((dr_type == R_X86_64_TPOFF64
4141                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
4142                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4143               outrel.r_info = htab->r_info (indx, dr_type);
4144
4145               elf_append_rela (output_bfd, sreloc, &outrel);
4146
4147               if (GOT_TLS_GD_P (tls_type))
4148                 {
4149                   if (indx == 0)
4150                     {
4151                       BFD_ASSERT (! unresolved_reloc);
4152                       bfd_put_64 (output_bfd,
4153                                   relocation - elf_x86_64_dtpoff_base (info),
4154                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4155                     }
4156                   else
4157                     {
4158                       bfd_put_64 (output_bfd, 0,
4159                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4160                       outrel.r_info = htab->r_info (indx,
4161                                                     R_X86_64_DTPOFF64);
4162                       outrel.r_offset += GOT_ENTRY_SIZE;
4163                       elf_append_rela (output_bfd, sreloc,
4164                                                 &outrel);
4165                     }
4166                 }
4167
4168             dr_done:
4169               if (h != NULL)
4170                 h->got.offset |= 1;
4171               else
4172                 local_got_offsets[r_symndx] |= 1;
4173             }
4174
4175           if (off >= (bfd_vma) -2
4176               && ! GOT_TLS_GDESC_P (tls_type))
4177             abort ();
4178           if (r_type == ELF32_R_TYPE (rel->r_info))
4179             {
4180               if (r_type == R_X86_64_GOTPC32_TLSDESC
4181                   || r_type == R_X86_64_TLSDESC_CALL)
4182                 relocation = htab->elf.sgotplt->output_section->vma
4183                   + htab->elf.sgotplt->output_offset
4184                   + offplt + htab->sgotplt_jump_table_size;
4185               else
4186                 relocation = htab->elf.sgot->output_section->vma
4187                   + htab->elf.sgot->output_offset + off;
4188               unresolved_reloc = FALSE;
4189             }
4190           else
4191             {
4192               bfd_vma roff = rel->r_offset;
4193
4194               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4195                 {
4196                   /* GD->IE transition.  For 64bit, change
4197                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4198                      .word 0x6666; rex64; call __tls_get_addr@plt
4199                      into:
4200                      movq %fs:0, %rax
4201                      addq foo@gottpoff(%rip), %rax
4202                      For 32bit, change
4203                      leaq foo@tlsgd(%rip), %rdi
4204                      .word 0x6666; rex64; call __tls_get_addr@plt
4205                      into:
4206                      movl %fs:0, %eax
4207                      addq foo@gottpoff(%rip), %rax */
4208                   if (ABI_64_P (output_bfd))
4209                     memcpy (contents + roff - 4,
4210                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4211                             16);
4212                   else
4213                     memcpy (contents + roff - 3,
4214                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4215                             15);
4216
4217                   relocation = (htab->elf.sgot->output_section->vma
4218                                 + htab->elf.sgot->output_offset + off
4219                                 - roff
4220                                 - input_section->output_section->vma
4221                                 - input_section->output_offset
4222                                 - 12);
4223                   bfd_put_32 (output_bfd, relocation,
4224                               contents + roff + 8);
4225                   /* Skip R_X86_64_PLT32.  */
4226                   rel++;
4227                   continue;
4228                 }
4229               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4230                 {
4231                   /* GDesc -> IE transition.
4232                      It's originally something like:
4233                      leaq x@tlsdesc(%rip), %rax
4234
4235                      Change it to:
4236                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
4237
4238                   /* Now modify the instruction as appropriate. To
4239                      turn a leaq into a movq in the form we use it, it
4240                      suffices to change the second byte from 0x8d to
4241                      0x8b.  */
4242                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4243
4244                   bfd_put_32 (output_bfd,
4245                               htab->elf.sgot->output_section->vma
4246                               + htab->elf.sgot->output_offset + off
4247                               - rel->r_offset
4248                               - input_section->output_section->vma
4249                               - input_section->output_offset
4250                               - 4,
4251                               contents + roff);
4252                   continue;
4253                 }
4254               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4255                 {
4256                   /* GDesc -> IE transition.
4257                      It's originally:
4258                      call *(%rax)
4259
4260                      Change it to:
4261                      xchg %ax, %ax.  */
4262
4263                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4264                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4265                   continue;
4266                 }
4267               else
4268                 BFD_ASSERT (FALSE);
4269             }
4270           break;
4271
4272         case R_X86_64_TLSLD:
4273           if (! elf_x86_64_tls_transition (info, input_bfd,
4274                                            input_section, contents,
4275                                            symtab_hdr, sym_hashes,
4276                                            &r_type, GOT_UNKNOWN,
4277                                            rel, relend, h, r_symndx))
4278             return FALSE;
4279
4280           if (r_type != R_X86_64_TLSLD)
4281             {
4282               /* LD->LE transition:
4283                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4284                  For 64bit, we change it into:
4285                  .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4286                  For 32bit, we change it into:
4287                  nopl 0x0(%rax); movl %fs:0, %eax.  */
4288
4289               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4290               if (ABI_64_P (output_bfd))
4291                 memcpy (contents + rel->r_offset - 3,
4292                         "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4293               else
4294                 memcpy (contents + rel->r_offset - 3,
4295                         "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4296               /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
4297               rel++;
4298               continue;
4299             }
4300
4301           if (htab->elf.sgot == NULL)
4302             abort ();
4303
4304           off = htab->tls_ld_got.offset;
4305           if (off & 1)
4306             off &= ~1;
4307           else
4308             {
4309               Elf_Internal_Rela outrel;
4310
4311               if (htab->elf.srelgot == NULL)
4312                 abort ();
4313
4314               outrel.r_offset = (htab->elf.sgot->output_section->vma
4315                                  + htab->elf.sgot->output_offset + off);
4316
4317               bfd_put_64 (output_bfd, 0,
4318                           htab->elf.sgot->contents + off);
4319               bfd_put_64 (output_bfd, 0,
4320                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4321               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4322               outrel.r_addend = 0;
4323               elf_append_rela (output_bfd, htab->elf.srelgot,
4324                                         &outrel);
4325               htab->tls_ld_got.offset |= 1;
4326             }
4327           relocation = htab->elf.sgot->output_section->vma
4328                        + htab->elf.sgot->output_offset + off;
4329           unresolved_reloc = FALSE;
4330           break;
4331
4332         case R_X86_64_DTPOFF32:
4333           if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4334             relocation -= elf_x86_64_dtpoff_base (info);
4335           else
4336             relocation = elf_x86_64_tpoff (info, relocation);
4337           break;
4338
4339         case R_X86_64_TPOFF32:
4340         case R_X86_64_TPOFF64:
4341           BFD_ASSERT (info->executable);
4342           relocation = elf_x86_64_tpoff (info, relocation);
4343           break;
4344
4345         default:
4346           break;
4347         }
4348
4349       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4350          because such sections are not SEC_ALLOC and thus ld.so will
4351          not process them.  */
4352       if (unresolved_reloc
4353           && !((input_section->flags & SEC_DEBUGGING) != 0
4354                && h->def_dynamic)
4355           && _bfd_elf_section_offset (output_bfd, info, input_section,
4356                                       rel->r_offset) != (bfd_vma) -1)
4357         {
4358           (*_bfd_error_handler)
4359             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4360              input_bfd,
4361              input_section,
4362              (long) rel->r_offset,
4363              howto->name,
4364              h->root.root.string);
4365           return FALSE;
4366         }
4367
4368 do_relocation:
4369       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4370                                     contents, rel->r_offset,
4371                                     relocation, rel->r_addend);
4372
4373 check_relocation_error:
4374       if (r != bfd_reloc_ok)
4375         {
4376           const char *name;
4377
4378           if (h != NULL)
4379             name = h->root.root.string;
4380           else
4381             {
4382               name = bfd_elf_string_from_elf_section (input_bfd,
4383                                                       symtab_hdr->sh_link,
4384                                                       sym->st_name);
4385               if (name == NULL)
4386                 return FALSE;
4387               if (*name == '\0')
4388                 name = bfd_section_name (input_bfd, sec);
4389             }
4390
4391           if (r == bfd_reloc_overflow)
4392             {
4393               if (! ((*info->callbacks->reloc_overflow)
4394                      (info, (h ? &h->root : NULL), name, howto->name,
4395                       (bfd_vma) 0, input_bfd, input_section,
4396                       rel->r_offset)))
4397                 return FALSE;
4398             }
4399           else
4400             {
4401               (*_bfd_error_handler)
4402                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4403                  input_bfd, input_section,
4404                  (long) rel->r_offset, name, (int) r);
4405               return FALSE;
4406             }
4407         }
4408     }
4409
4410   return TRUE;
4411 }
4412
4413 /* Finish up dynamic symbol handling.  We set the contents of various
4414    dynamic sections here.  */
4415
4416 static bfd_boolean
4417 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4418                                   struct bfd_link_info *info,
4419                                   struct elf_link_hash_entry *h,
4420                                   Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4421 {
4422   struct elf_x86_64_link_hash_table *htab;
4423   const struct elf_x86_64_backend_data *const abed
4424     = get_elf_x86_64_backend_data (output_bfd);
4425
4426   htab = elf_x86_64_hash_table (info);
4427   if (htab == NULL)
4428     return FALSE;
4429
4430   if (h->plt.offset != (bfd_vma) -1)
4431     {
4432       bfd_vma plt_index;
4433       bfd_vma got_offset;
4434       Elf_Internal_Rela rela;
4435       bfd_byte *loc;
4436       asection *plt, *gotplt, *relplt;
4437       const struct elf_backend_data *bed;
4438
4439       /* When building a static executable, use .iplt, .igot.plt and
4440          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4441       if (htab->elf.splt != NULL)
4442         {
4443           plt = htab->elf.splt;
4444           gotplt = htab->elf.sgotplt;
4445           relplt = htab->elf.srelplt;
4446         }
4447       else
4448         {
4449           plt = htab->elf.iplt;
4450           gotplt = htab->elf.igotplt;
4451           relplt = htab->elf.irelplt;
4452         }
4453
4454       /* This symbol has an entry in the procedure linkage table.  Set
4455          it up.  */
4456       if ((h->dynindx == -1
4457            && !((h->forced_local || info->executable)
4458                 && h->def_regular
4459                 && h->type == STT_GNU_IFUNC))
4460           || plt == NULL
4461           || gotplt == NULL
4462           || relplt == NULL)
4463         abort ();
4464
4465       /* Get the index in the procedure linkage table which
4466          corresponds to this symbol.  This is the index of this symbol
4467          in all the symbols for which we are making plt entries.  The
4468          first entry in the procedure linkage table is reserved.
4469
4470          Get the offset into the .got table of the entry that
4471          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
4472          bytes. The first three are reserved for the dynamic linker.
4473
4474          For static executables, we don't reserve anything.  */
4475
4476       if (plt == htab->elf.splt)
4477         {
4478           got_offset = h->plt.offset / abed->plt_entry_size - 1;
4479           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4480         }
4481       else
4482         {
4483           got_offset = h->plt.offset / abed->plt_entry_size;
4484           got_offset = got_offset * GOT_ENTRY_SIZE;
4485         }
4486
4487       /* Fill in the entry in the procedure linkage table.  */
4488       memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4489               abed->plt_entry_size);
4490
4491       /* Insert the relocation positions of the plt section.  */
4492
4493       /* Put offset the PC-relative instruction referring to the GOT entry,
4494          subtracting the size of that instruction.  */
4495       bfd_put_32 (output_bfd,
4496                   (gotplt->output_section->vma
4497                    + gotplt->output_offset
4498                    + got_offset
4499                    - plt->output_section->vma
4500                    - plt->output_offset
4501                    - h->plt.offset
4502                    - abed->plt_got_insn_size),
4503                   plt->contents + h->plt.offset + abed->plt_got_offset);
4504
4505       /* Fill in the entry in the global offset table, initially this
4506          points to the second part of the PLT entry.  */
4507       bfd_put_64 (output_bfd, (plt->output_section->vma
4508                                + plt->output_offset
4509                                + h->plt.offset + abed->plt_lazy_offset),
4510                   gotplt->contents + got_offset);
4511
4512       /* Fill in the entry in the .rela.plt section.  */
4513       rela.r_offset = (gotplt->output_section->vma
4514                        + gotplt->output_offset
4515                        + got_offset);
4516       if (h->dynindx == -1
4517           || ((info->executable
4518                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4519               && h->def_regular
4520               && h->type == STT_GNU_IFUNC))
4521         {
4522           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4523              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
4524           rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4525           rela.r_addend = (h->root.u.def.value
4526                            + h->root.u.def.section->output_section->vma
4527                            + h->root.u.def.section->output_offset);
4528           /* R_X86_64_IRELATIVE comes last.  */
4529           plt_index = htab->next_irelative_index--;
4530         }
4531       else
4532         {
4533           rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4534           rela.r_addend = 0;
4535           plt_index = htab->next_jump_slot_index++;
4536         }
4537
4538       /* Don't fill PLT entry for static executables.  */
4539       if (plt == htab->elf.splt)
4540         {
4541           /* Put relocation index.  */
4542           bfd_put_32 (output_bfd, plt_index,
4543                       plt->contents + h->plt.offset + abed->plt_reloc_offset);
4544           /* Put offset for jmp .PLT0.  */
4545           bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4546                       plt->contents + h->plt.offset + abed->plt_plt_offset);
4547         }
4548
4549       bed = get_elf_backend_data (output_bfd);
4550       loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4551       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4552
4553       if (!h->def_regular)
4554         {
4555           /* Mark the symbol as undefined, rather than as defined in
4556              the .plt section.  Leave the value if there were any
4557              relocations where pointer equality matters (this is a clue
4558              for the dynamic linker, to make function pointer
4559              comparisons work between an application and shared
4560              library), otherwise set it to zero.  If a function is only
4561              called from a binary, there is no need to slow down
4562              shared libraries because of that.  */
4563           sym->st_shndx = SHN_UNDEF;
4564           if (!h->pointer_equality_needed)
4565             sym->st_value = 0;
4566         }
4567     }
4568
4569   if (h->got.offset != (bfd_vma) -1
4570       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4571       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4572     {
4573       Elf_Internal_Rela rela;
4574
4575       /* This symbol has an entry in the global offset table.  Set it
4576          up.  */
4577       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4578         abort ();
4579
4580       rela.r_offset = (htab->elf.sgot->output_section->vma
4581                        + htab->elf.sgot->output_offset
4582                        + (h->got.offset &~ (bfd_vma) 1));
4583
4584       /* If this is a static link, or it is a -Bsymbolic link and the
4585          symbol is defined locally or was forced to be local because
4586          of a version file, we just want to emit a RELATIVE reloc.
4587          The entry in the global offset table will already have been
4588          initialized in the relocate_section function.  */
4589       if (h->def_regular
4590           && h->type == STT_GNU_IFUNC)
4591         {
4592           if (info->shared)
4593             {
4594               /* Generate R_X86_64_GLOB_DAT.  */
4595               goto do_glob_dat;
4596             }
4597           else
4598             {
4599               asection *plt;
4600
4601               if (!h->pointer_equality_needed)
4602                 abort ();
4603
4604               /* For non-shared object, we can't use .got.plt, which
4605                  contains the real function addres if we need pointer
4606                  equality.  We load the GOT entry with the PLT entry.  */
4607               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4608               bfd_put_64 (output_bfd, (plt->output_section->vma
4609                                        + plt->output_offset
4610                                        + h->plt.offset),
4611                           htab->elf.sgot->contents + h->got.offset);
4612               return TRUE;
4613             }
4614         }
4615       else if (info->shared
4616                && SYMBOL_REFERENCES_LOCAL (info, h))
4617         {
4618           if (!h->def_regular)
4619             return FALSE;
4620           BFD_ASSERT((h->got.offset & 1) != 0);
4621           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4622           rela.r_addend = (h->root.u.def.value
4623                            + h->root.u.def.section->output_section->vma
4624                            + h->root.u.def.section->output_offset);
4625         }
4626       else
4627         {
4628           BFD_ASSERT((h->got.offset & 1) == 0);
4629 do_glob_dat:
4630           bfd_put_64 (output_bfd, (bfd_vma) 0,
4631                       htab->elf.sgot->contents + h->got.offset);
4632           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4633           rela.r_addend = 0;
4634         }
4635
4636       elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4637     }
4638
4639   if (h->needs_copy)
4640     {
4641       Elf_Internal_Rela rela;
4642
4643       /* This symbol needs a copy reloc.  Set it up.  */
4644
4645       if (h->dynindx == -1
4646           || (h->root.type != bfd_link_hash_defined
4647               && h->root.type != bfd_link_hash_defweak)
4648           || htab->srelbss == NULL)
4649         abort ();
4650
4651       rela.r_offset = (h->root.u.def.value
4652                        + h->root.u.def.section->output_section->vma
4653                        + h->root.u.def.section->output_offset);
4654       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4655       rela.r_addend = 0;
4656       elf_append_rela (output_bfd, htab->srelbss, &rela);
4657     }
4658
4659   return TRUE;
4660 }
4661
4662 /* Finish up local dynamic symbol handling.  We set the contents of
4663    various dynamic sections here.  */
4664
4665 static bfd_boolean
4666 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4667 {
4668   struct elf_link_hash_entry *h
4669     = (struct elf_link_hash_entry *) *slot;
4670   struct bfd_link_info *info
4671     = (struct bfd_link_info *) inf;
4672
4673   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4674                                              info, h, NULL);
4675 }
4676
4677 /* Used to decide how to sort relocs in an optimal manner for the
4678    dynamic linker, before writing them out.  */
4679
4680 static enum elf_reloc_type_class
4681 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4682 {
4683   switch ((int) ELF32_R_TYPE (rela->r_info))
4684     {
4685     case R_X86_64_RELATIVE:
4686     case R_X86_64_RELATIVE64:
4687       return reloc_class_relative;
4688     case R_X86_64_JUMP_SLOT:
4689       return reloc_class_plt;
4690     case R_X86_64_COPY:
4691       return reloc_class_copy;
4692     default:
4693       return reloc_class_normal;
4694     }
4695 }
4696
4697 /* Finish up the dynamic sections.  */
4698
4699 static bfd_boolean
4700 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4701                                     struct bfd_link_info *info)
4702 {
4703   struct elf_x86_64_link_hash_table *htab;
4704   bfd *dynobj;
4705   asection *sdyn;
4706   const struct elf_x86_64_backend_data *const abed
4707     = get_elf_x86_64_backend_data (output_bfd);
4708
4709   htab = elf_x86_64_hash_table (info);
4710   if (htab == NULL)
4711     return FALSE;
4712
4713   dynobj = htab->elf.dynobj;
4714   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4715
4716   if (htab->elf.dynamic_sections_created)
4717     {
4718       bfd_byte *dyncon, *dynconend;
4719       const struct elf_backend_data *bed;
4720       bfd_size_type sizeof_dyn;
4721
4722       if (sdyn == NULL || htab->elf.sgot == NULL)
4723         abort ();
4724
4725       bed = get_elf_backend_data (dynobj);
4726       sizeof_dyn = bed->s->sizeof_dyn;
4727       dyncon = sdyn->contents;
4728       dynconend = sdyn->contents + sdyn->size;
4729       for (; dyncon < dynconend; dyncon += sizeof_dyn)
4730         {
4731           Elf_Internal_Dyn dyn;
4732           asection *s;
4733
4734           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4735
4736           switch (dyn.d_tag)
4737             {
4738             default:
4739               continue;
4740
4741             case DT_PLTGOT:
4742               s = htab->elf.sgotplt;
4743               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4744               break;
4745
4746             case DT_JMPREL:
4747               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4748               break;
4749
4750             case DT_PLTRELSZ:
4751               s = htab->elf.srelplt->output_section;
4752               dyn.d_un.d_val = s->size;
4753               break;
4754
4755             case DT_RELASZ:
4756               /* The procedure linkage table relocs (DT_JMPREL) should
4757                  not be included in the overall relocs (DT_RELA).
4758                  Therefore, we override the DT_RELASZ entry here to
4759                  make it not include the JMPREL relocs.  Since the
4760                  linker script arranges for .rela.plt to follow all
4761                  other relocation sections, we don't have to worry
4762                  about changing the DT_RELA entry.  */
4763               if (htab->elf.srelplt != NULL)
4764                 {
4765                   s = htab->elf.srelplt->output_section;
4766                   dyn.d_un.d_val -= s->size;
4767                 }
4768               break;
4769
4770             case DT_TLSDESC_PLT:
4771               s = htab->elf.splt;
4772               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4773                 + htab->tlsdesc_plt;
4774               break;
4775
4776             case DT_TLSDESC_GOT:
4777               s = htab->elf.sgot;
4778               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4779                 + htab->tlsdesc_got;
4780               break;
4781             }
4782
4783           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4784         }
4785
4786       /* Fill in the special first entry in the procedure linkage table.  */
4787       if (htab->elf.splt && htab->elf.splt->size > 0)
4788         {
4789           /* Fill in the first entry in the procedure linkage table.  */
4790           memcpy (htab->elf.splt->contents,
4791                   abed->plt0_entry, abed->plt_entry_size);
4792           /* Add offset for pushq GOT+8(%rip), since the instruction
4793              uses 6 bytes subtract this value.  */
4794           bfd_put_32 (output_bfd,
4795                       (htab->elf.sgotplt->output_section->vma
4796                        + htab->elf.sgotplt->output_offset
4797                        + 8
4798                        - htab->elf.splt->output_section->vma
4799                        - htab->elf.splt->output_offset
4800                        - 6),
4801                       htab->elf.splt->contents + abed->plt0_got1_offset);
4802           /* Add offset for the PC-relative instruction accessing GOT+16,
4803              subtracting the offset to the end of that instruction.  */
4804           bfd_put_32 (output_bfd,
4805                       (htab->elf.sgotplt->output_section->vma
4806                        + htab->elf.sgotplt->output_offset
4807                        + 16
4808                        - htab->elf.splt->output_section->vma
4809                        - htab->elf.splt->output_offset
4810                        - abed->plt0_got2_insn_end),
4811                       htab->elf.splt->contents + abed->plt0_got2_offset);
4812
4813           elf_section_data (htab->elf.splt->output_section)
4814             ->this_hdr.sh_entsize = abed->plt_entry_size;
4815
4816           if (htab->tlsdesc_plt)
4817             {
4818               bfd_put_64 (output_bfd, (bfd_vma) 0,
4819                           htab->elf.sgot->contents + htab->tlsdesc_got);
4820
4821               memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4822                       abed->plt0_entry, abed->plt_entry_size);
4823
4824               /* Add offset for pushq GOT+8(%rip), since the
4825                  instruction uses 6 bytes subtract this value.  */
4826               bfd_put_32 (output_bfd,
4827                           (htab->elf.sgotplt->output_section->vma
4828                            + htab->elf.sgotplt->output_offset
4829                            + 8
4830                            - htab->elf.splt->output_section->vma
4831                            - htab->elf.splt->output_offset
4832                            - htab->tlsdesc_plt
4833                            - 6),
4834                           htab->elf.splt->contents
4835                           + htab->tlsdesc_plt + abed->plt0_got1_offset);
4836           /* Add offset for the PC-relative instruction accessing GOT+TDG,
4837              where TGD stands for htab->tlsdesc_got, subtracting the offset
4838              to the end of that instruction.  */
4839               bfd_put_32 (output_bfd,
4840                           (htab->elf.sgot->output_section->vma
4841                            + htab->elf.sgot->output_offset
4842                            + htab->tlsdesc_got
4843                            - htab->elf.splt->output_section->vma
4844                            - htab->elf.splt->output_offset
4845                            - htab->tlsdesc_plt
4846                            - abed->plt0_got2_insn_end),
4847                           htab->elf.splt->contents
4848                           + htab->tlsdesc_plt + abed->plt0_got2_offset);
4849             }
4850         }
4851     }
4852
4853   if (htab->elf.sgotplt)
4854     {
4855       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4856         {
4857           (*_bfd_error_handler)
4858             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4859           return FALSE;
4860         }
4861
4862       /* Fill in the first three entries in the global offset table.  */
4863       if (htab->elf.sgotplt->size > 0)
4864         {
4865           /* Set the first entry in the global offset table to the address of
4866              the dynamic section.  */
4867           if (sdyn == NULL)
4868             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4869           else
4870             bfd_put_64 (output_bfd,
4871                         sdyn->output_section->vma + sdyn->output_offset,
4872                         htab->elf.sgotplt->contents);
4873           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
4874           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4875           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4876         }
4877
4878       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4879         GOT_ENTRY_SIZE;
4880     }
4881
4882   /* Adjust .eh_frame for .plt section.  */
4883   if (htab->plt_eh_frame != NULL
4884       && htab->plt_eh_frame->contents != NULL)
4885     {
4886       if (htab->elf.splt != NULL
4887           && htab->elf.splt->size != 0
4888           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4889           && htab->elf.splt->output_section != NULL
4890           && htab->plt_eh_frame->output_section != NULL)
4891         {
4892           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4893           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4894                                    + htab->plt_eh_frame->output_offset
4895                                    + PLT_FDE_START_OFFSET;
4896           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4897                              htab->plt_eh_frame->contents
4898                              + PLT_FDE_START_OFFSET);
4899         }
4900       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4901         {
4902           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4903                                                  htab->plt_eh_frame,
4904                                                  htab->plt_eh_frame->contents))
4905             return FALSE;
4906         }
4907     }
4908
4909   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4910     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4911       = GOT_ENTRY_SIZE;
4912
4913   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4914   htab_traverse (htab->loc_hash_table,
4915                  elf_x86_64_finish_local_dynamic_symbol,
4916                  info);
4917
4918   return TRUE;
4919 }
4920
4921 /* Return address for Ith PLT stub in section PLT, for relocation REL
4922    or (bfd_vma) -1 if it should not be included.  */
4923
4924 static bfd_vma
4925 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4926                         const arelent *rel ATTRIBUTE_UNUSED)
4927 {
4928   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4929 }
4930
4931 /* Handle an x86-64 specific section when reading an object file.  This
4932    is called when elfcode.h finds a section with an unknown type.  */
4933
4934 static bfd_boolean
4935 elf_x86_64_section_from_shdr (bfd *abfd,
4936                                 Elf_Internal_Shdr *hdr,
4937                                 const char *name,
4938                                 int shindex)
4939 {
4940   if (hdr->sh_type != SHT_X86_64_UNWIND)
4941     return FALSE;
4942
4943   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4944     return FALSE;
4945
4946   return TRUE;
4947 }
4948
4949 /* Hook called by the linker routine which adds symbols from an object
4950    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4951    of .bss.  */
4952
4953 static bfd_boolean
4954 elf_x86_64_add_symbol_hook (bfd *abfd,
4955                             struct bfd_link_info *info,
4956                             Elf_Internal_Sym *sym,
4957                             const char **namep ATTRIBUTE_UNUSED,
4958                             flagword *flagsp ATTRIBUTE_UNUSED,
4959                             asection **secp,
4960                             bfd_vma *valp)
4961 {
4962   asection *lcomm;
4963
4964   switch (sym->st_shndx)
4965     {
4966     case SHN_X86_64_LCOMMON:
4967       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4968       if (lcomm == NULL)
4969         {
4970           lcomm = bfd_make_section_with_flags (abfd,
4971                                                "LARGE_COMMON",
4972                                                (SEC_ALLOC
4973                                                 | SEC_IS_COMMON
4974                                                 | SEC_LINKER_CREATED));
4975           if (lcomm == NULL)
4976             return FALSE;
4977           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4978         }
4979       *secp = lcomm;
4980       *valp = sym->st_size;
4981       return TRUE;
4982     }
4983
4984   if ((abfd->flags & DYNAMIC) == 0
4985       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4986           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4987     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4988
4989   return TRUE;
4990 }
4991
4992
4993 /* Given a BFD section, try to locate the corresponding ELF section
4994    index.  */
4995
4996 static bfd_boolean
4997 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4998                                          asection *sec, int *index_return)
4999 {
5000   if (sec == &_bfd_elf_large_com_section)
5001     {
5002       *index_return = SHN_X86_64_LCOMMON;
5003       return TRUE;
5004     }
5005   return FALSE;
5006 }
5007
5008 /* Process a symbol.  */
5009
5010 static void
5011 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5012                               asymbol *asym)
5013 {
5014   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5015
5016   switch (elfsym->internal_elf_sym.st_shndx)
5017     {
5018     case SHN_X86_64_LCOMMON:
5019       asym->section = &_bfd_elf_large_com_section;
5020       asym->value = elfsym->internal_elf_sym.st_size;
5021       /* Common symbol doesn't set BSF_GLOBAL.  */
5022       asym->flags &= ~BSF_GLOBAL;
5023       break;
5024     }
5025 }
5026
5027 static bfd_boolean
5028 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5029 {
5030   return (sym->st_shndx == SHN_COMMON
5031           || sym->st_shndx == SHN_X86_64_LCOMMON);
5032 }
5033
5034 static unsigned int
5035 elf_x86_64_common_section_index (asection *sec)
5036 {
5037   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5038     return SHN_COMMON;
5039   else
5040     return SHN_X86_64_LCOMMON;
5041 }
5042
5043 static asection *
5044 elf_x86_64_common_section (asection *sec)
5045 {
5046   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5047     return bfd_com_section_ptr;
5048   else
5049     return &_bfd_elf_large_com_section;
5050 }
5051
5052 static bfd_boolean
5053 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5054                          struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
5055                          struct elf_link_hash_entry *h,
5056                          Elf_Internal_Sym *sym,
5057                          asection **psec,
5058                          bfd_vma *pvalue ATTRIBUTE_UNUSED,
5059                          unsigned int *pold_alignment ATTRIBUTE_UNUSED,
5060                          bfd_boolean *skip ATTRIBUTE_UNUSED,
5061                          bfd_boolean *override ATTRIBUTE_UNUSED,
5062                          bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
5063                          bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
5064                          bfd_boolean *newdyn ATTRIBUTE_UNUSED,
5065                          bfd_boolean *newdef,
5066                          bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
5067                          bfd_boolean *newweak ATTRIBUTE_UNUSED,
5068                          bfd *abfd ATTRIBUTE_UNUSED,
5069                          asection **sec,
5070                          bfd_boolean *olddyn ATTRIBUTE_UNUSED,
5071                          bfd_boolean *olddef,
5072                          bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
5073                          bfd_boolean *oldweak ATTRIBUTE_UNUSED,
5074                          bfd *oldbfd,
5075                          asection **oldsec)
5076 {
5077   /* A normal common symbol and a large common symbol result in a
5078      normal common symbol.  We turn the large common symbol into a
5079      normal one.  */
5080   if (!*olddef
5081       && h->root.type == bfd_link_hash_common
5082       && !*newdef
5083       && bfd_is_com_section (*sec)
5084       && *oldsec != *sec)
5085     {
5086       if (sym->st_shndx == SHN_COMMON
5087           && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
5088         {
5089           h->root.u.c.p->section
5090             = bfd_make_section_old_way (oldbfd, "COMMON");
5091           h->root.u.c.p->section->flags = SEC_ALLOC;
5092         }
5093       else if (sym->st_shndx == SHN_X86_64_LCOMMON
5094                && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
5095         *psec = *sec = bfd_com_section_ptr;
5096     }
5097
5098   return TRUE;
5099 }
5100
5101 static int
5102 elf_x86_64_additional_program_headers (bfd *abfd,
5103                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
5104 {
5105   asection *s;
5106   int count = 0;
5107
5108   /* Check to see if we need a large readonly segment.  */
5109   s = bfd_get_section_by_name (abfd, ".lrodata");
5110   if (s && (s->flags & SEC_LOAD))
5111     count++;
5112
5113   /* Check to see if we need a large data segment.  Since .lbss sections
5114      is placed right after the .bss section, there should be no need for
5115      a large data segment just because of .lbss.  */
5116   s = bfd_get_section_by_name (abfd, ".ldata");
5117   if (s && (s->flags & SEC_LOAD))
5118     count++;
5119
5120   return count;
5121 }
5122
5123 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5124
5125 static bfd_boolean
5126 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5127 {
5128   if (h->plt.offset != (bfd_vma) -1
5129       && !h->def_regular
5130       && !h->pointer_equality_needed)
5131     return FALSE;
5132
5133   return _bfd_elf_hash_symbol (h);
5134 }
5135
5136 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5137
5138 static bfd_boolean
5139 elf_x86_64_relocs_compatible (const bfd_target *input,
5140                               const bfd_target *output)
5141 {
5142   return ((xvec_get_elf_backend_data (input)->s->elfclass
5143            == xvec_get_elf_backend_data (output)->s->elfclass)
5144           && _bfd_elf_relocs_compatible (input, output));
5145 }
5146
5147 static const struct bfd_elf_special_section
5148   elf_x86_64_special_sections[]=
5149 {
5150   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5151   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5152   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5153   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5154   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5155   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5156   { NULL,                       0,          0, 0,            0 }
5157 };
5158
5159 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
5160 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
5161 #define ELF_ARCH                            bfd_arch_i386
5162 #define ELF_TARGET_ID                       X86_64_ELF_DATA
5163 #define ELF_MACHINE_CODE                    EM_X86_64
5164 #define ELF_MAXPAGESIZE                     0x200000
5165 #define ELF_MINPAGESIZE                     0x1000
5166 #define ELF_COMMONPAGESIZE                  0x1000
5167
5168 #define elf_backend_can_gc_sections         1
5169 #define elf_backend_can_refcount            1
5170 #define elf_backend_want_got_plt            1
5171 #define elf_backend_plt_readonly            1
5172 #define elf_backend_want_plt_sym            0
5173 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
5174 #define elf_backend_rela_normal             1
5175 #define elf_backend_plt_alignment           4
5176
5177 #define elf_info_to_howto                   elf_x86_64_info_to_howto
5178
5179 #define bfd_elf64_bfd_link_hash_table_create \
5180   elf_x86_64_link_hash_table_create
5181 #define bfd_elf64_bfd_link_hash_table_free \
5182   elf_x86_64_link_hash_table_free
5183 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
5184 #define bfd_elf64_bfd_reloc_name_lookup \
5185   elf_x86_64_reloc_name_lookup
5186
5187 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
5188 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
5189 #define elf_backend_check_relocs            elf_x86_64_check_relocs
5190 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
5191 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5192 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5193 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
5194 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
5195 #define elf_backend_gc_sweep_hook           elf_x86_64_gc_sweep_hook
5196 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
5197 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
5198 #ifdef CORE_HEADER
5199 #define elf_backend_write_core_note         elf_x86_64_write_core_note
5200 #endif
5201 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
5202 #define elf_backend_relocate_section        elf_x86_64_relocate_section
5203 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
5204 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
5205 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
5206 #define elf_backend_plt_sym_val             elf_x86_64_plt_sym_val
5207 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5208 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
5209
5210 #define elf_backend_section_from_shdr \
5211         elf_x86_64_section_from_shdr
5212
5213 #define elf_backend_section_from_bfd_section \
5214   elf_x86_64_elf_section_from_bfd_section
5215 #define elf_backend_add_symbol_hook \
5216   elf_x86_64_add_symbol_hook
5217 #define elf_backend_symbol_processing \
5218   elf_x86_64_symbol_processing
5219 #define elf_backend_common_section_index \
5220   elf_x86_64_common_section_index
5221 #define elf_backend_common_section \
5222   elf_x86_64_common_section
5223 #define elf_backend_common_definition \
5224   elf_x86_64_common_definition
5225 #define elf_backend_merge_symbol \
5226   elf_x86_64_merge_symbol
5227 #define elf_backend_special_sections \
5228   elf_x86_64_special_sections
5229 #define elf_backend_additional_program_headers \
5230   elf_x86_64_additional_program_headers
5231 #define elf_backend_hash_symbol \
5232   elf_x86_64_hash_symbol
5233
5234 #define elf_backend_post_process_headers  _bfd_elf_set_osabi
5235
5236 #include "elf64-target.h"
5237
5238 /* FreeBSD support.  */
5239
5240 #undef  TARGET_LITTLE_SYM
5241 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_freebsd_vec
5242 #undef  TARGET_LITTLE_NAME
5243 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
5244
5245 #undef  ELF_OSABI
5246 #define ELF_OSABI                           ELFOSABI_FREEBSD
5247
5248 #undef  elf64_bed
5249 #define elf64_bed elf64_x86_64_fbsd_bed
5250
5251 #include "elf64-target.h"
5252
5253 /* Solaris 2 support.  */
5254
5255 #undef  TARGET_LITTLE_SYM
5256 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_sol2_vec
5257 #undef  TARGET_LITTLE_NAME
5258 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
5259
5260 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5261    objects won't be recognized.  */
5262 #undef ELF_OSABI
5263
5264 #undef  elf64_bed
5265 #define elf64_bed                           elf64_x86_64_sol2_bed
5266
5267 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5268    boundary.  */
5269 #undef elf_backend_static_tls_alignment
5270 #define elf_backend_static_tls_alignment    16
5271
5272 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5273
5274    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5275    File, p.63.  */
5276 #undef elf_backend_want_plt_sym
5277 #define elf_backend_want_plt_sym            1
5278
5279 #include "elf64-target.h"
5280
5281 /* Native Client support.  */
5282
5283 #undef  TARGET_LITTLE_SYM
5284 #define TARGET_LITTLE_SYM               bfd_elf64_x86_64_nacl_vec
5285 #undef  TARGET_LITTLE_NAME
5286 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
5287 #undef  elf64_bed
5288 #define elf64_bed                       elf64_x86_64_nacl_bed
5289
5290 #undef  ELF_MAXPAGESIZE
5291 #undef  ELF_MINPAGESIZE
5292 #undef  ELF_COMMONPAGESIZE
5293 #define ELF_MAXPAGESIZE                 0x10000
5294 #define ELF_MINPAGESIZE                 0x10000
5295 #define ELF_COMMONPAGESIZE              0x10000
5296
5297 /* Restore defaults.  */
5298 #undef  ELF_OSABI
5299 #undef  elf_backend_static_tls_alignment
5300 #undef  elf_backend_want_plt_sym
5301 #define elf_backend_want_plt_sym        0
5302
5303 /* NaCl uses substantially different PLT entries for the same effects.  */
5304
5305 #undef  elf_backend_plt_alignment
5306 #define elf_backend_plt_alignment       5
5307 #define NACL_PLT_ENTRY_SIZE             64
5308 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5309
5310 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5311   {
5312     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
5313     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
5314     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5315     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5316     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5317
5318     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
5319     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5320
5321     /* 32 bytes of nop to pad out to the standard size.  */
5322     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5323     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5324     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5325     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5326     0x66,                                  /* excess data32 prefix      */
5327     0x90                                   /* nop */
5328   };
5329
5330 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5331   {
5332     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
5333     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5334     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5335     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5336
5337     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
5338     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5339     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5340
5341     /* Lazy GOT entries point here (32-byte aligned).  */
5342     0x68,                 /* pushq immediate */
5343     0, 0, 0, 0,           /* replaced with index into relocation table.  */
5344     0xe9,                 /* jmp relative */
5345     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
5346
5347     /* 22 bytes of nop to pad out to the standard size.  */
5348     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5349     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5350     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
5351   };
5352
5353 /* .eh_frame covering the .plt section.  */
5354
5355 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5356   {
5357 #if (PLT_CIE_LENGTH != 20                               \
5358      || PLT_FDE_LENGTH != 36                            \
5359      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5360      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5361 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5362 #endif
5363     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
5364     0, 0, 0, 0,                 /* CIE ID */
5365     1,                          /* CIE version */
5366     'z', 'R', 0,                /* Augmentation string */
5367     1,                          /* Code alignment factor */
5368     0x78,                       /* Data alignment factor */
5369     16,                         /* Return address column */
5370     1,                          /* Augmentation size */
5371     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5372     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5373     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
5374     DW_CFA_nop, DW_CFA_nop,
5375
5376     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
5377     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5378     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
5379     0, 0, 0, 0,                 /* .plt size goes here */
5380     0,                          /* Augmentation size */
5381     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
5382     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5383     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
5384     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5385     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
5386     13,                         /* Block length */
5387     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
5388     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
5389     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5390     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5391     DW_CFA_nop, DW_CFA_nop
5392   };
5393
5394 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5395   {
5396     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
5397     elf_x86_64_nacl_plt_entry,               /* plt_entry */
5398     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
5399     2,                                       /* plt0_got1_offset */
5400     9,                                       /* plt0_got2_offset */
5401     13,                                      /* plt0_got2_insn_end */
5402     3,                                       /* plt_got_offset */
5403     33,                                      /* plt_reloc_offset */
5404     38,                                      /* plt_plt_offset */
5405     7,                                       /* plt_got_insn_size */
5406     42,                                      /* plt_plt_insn_end */
5407     32,                                      /* plt_lazy_offset */
5408     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
5409     sizeof (elf_x86_64_nacl_eh_frame_plt),   /* eh_frame_plt_size */
5410   };
5411
5412 #undef  elf_backend_arch_data
5413 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
5414
5415 #undef  elf_backend_modify_segment_map
5416 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5417 #undef  elf_backend_modify_program_headers
5418 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5419
5420 #include "elf64-target.h"
5421
5422 /* Native Client x32 support.  */
5423
5424 #undef  TARGET_LITTLE_SYM
5425 #define TARGET_LITTLE_SYM               bfd_elf32_x86_64_nacl_vec
5426 #undef  TARGET_LITTLE_NAME
5427 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
5428 #undef  elf32_bed
5429 #define elf32_bed                       elf32_x86_64_nacl_bed
5430
5431 #define bfd_elf32_bfd_link_hash_table_create \
5432   elf_x86_64_link_hash_table_create
5433 #define bfd_elf32_bfd_link_hash_table_free \
5434   elf_x86_64_link_hash_table_free
5435 #define bfd_elf32_bfd_reloc_type_lookup \
5436   elf_x86_64_reloc_type_lookup
5437 #define bfd_elf32_bfd_reloc_name_lookup \
5438   elf_x86_64_reloc_name_lookup
5439 #define bfd_elf32_mkobject \
5440   elf_x86_64_mkobject
5441
5442 #undef elf_backend_object_p
5443 #define elf_backend_object_p \
5444   elf32_x86_64_elf_object_p
5445
5446 #undef elf_backend_bfd_from_remote_memory
5447 #define elf_backend_bfd_from_remote_memory \
5448   _bfd_elf32_bfd_from_remote_memory
5449
5450 #undef elf_backend_size_info
5451 #define elf_backend_size_info \
5452   _bfd_elf32_size_info
5453
5454 #include "elf32-target.h"
5455
5456 /* Restore defaults.  */
5457 #undef  elf_backend_object_p
5458 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5459 #undef  elf_backend_bfd_from_remote_memory
5460 #undef  elf_backend_size_info
5461 #undef  elf_backend_modify_segment_map
5462 #undef  elf_backend_modify_program_headers
5463
5464 /* Intel L1OM support.  */
5465
5466 static bfd_boolean
5467 elf64_l1om_elf_object_p (bfd *abfd)
5468 {
5469   /* Set the right machine number for an L1OM elf64 file.  */
5470   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5471   return TRUE;
5472 }
5473
5474 #undef  TARGET_LITTLE_SYM
5475 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_vec
5476 #undef  TARGET_LITTLE_NAME
5477 #define TARGET_LITTLE_NAME                  "elf64-l1om"
5478 #undef ELF_ARCH
5479 #define ELF_ARCH                            bfd_arch_l1om
5480
5481 #undef  ELF_MACHINE_CODE
5482 #define ELF_MACHINE_CODE                    EM_L1OM
5483
5484 #undef  ELF_OSABI
5485
5486 #undef  elf64_bed
5487 #define elf64_bed elf64_l1om_bed
5488
5489 #undef elf_backend_object_p
5490 #define elf_backend_object_p                elf64_l1om_elf_object_p
5491
5492 /* Restore defaults.  */
5493 #undef  ELF_MAXPAGESIZE
5494 #undef  ELF_MINPAGESIZE
5495 #undef  ELF_COMMONPAGESIZE
5496 #define ELF_MAXPAGESIZE                 0x200000
5497 #define ELF_MINPAGESIZE                 0x1000
5498 #define ELF_COMMONPAGESIZE              0x1000
5499 #undef  elf_backend_plt_alignment
5500 #define elf_backend_plt_alignment       4
5501 #undef  elf_backend_arch_data
5502 #define elf_backend_arch_data   &elf_x86_64_arch_bed
5503
5504 #include "elf64-target.h"
5505
5506 /* FreeBSD L1OM support.  */
5507
5508 #undef  TARGET_LITTLE_SYM
5509 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_freebsd_vec
5510 #undef  TARGET_LITTLE_NAME
5511 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
5512
5513 #undef  ELF_OSABI
5514 #define ELF_OSABI                           ELFOSABI_FREEBSD
5515
5516 #undef  elf64_bed
5517 #define elf64_bed elf64_l1om_fbsd_bed
5518
5519 #include "elf64-target.h"
5520
5521 /* Intel K1OM support.  */
5522
5523 static bfd_boolean
5524 elf64_k1om_elf_object_p (bfd *abfd)
5525 {
5526   /* Set the right machine number for an K1OM elf64 file.  */
5527   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5528   return TRUE;
5529 }
5530
5531 #undef  TARGET_LITTLE_SYM
5532 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_vec
5533 #undef  TARGET_LITTLE_NAME
5534 #define TARGET_LITTLE_NAME                  "elf64-k1om"
5535 #undef ELF_ARCH
5536 #define ELF_ARCH                            bfd_arch_k1om
5537
5538 #undef  ELF_MACHINE_CODE
5539 #define ELF_MACHINE_CODE                    EM_K1OM
5540
5541 #undef  ELF_OSABI
5542
5543 #undef  elf64_bed
5544 #define elf64_bed elf64_k1om_bed
5545
5546 #undef elf_backend_object_p
5547 #define elf_backend_object_p                elf64_k1om_elf_object_p
5548
5549 #undef  elf_backend_static_tls_alignment
5550
5551 #undef elf_backend_want_plt_sym
5552 #define elf_backend_want_plt_sym            0
5553
5554 #include "elf64-target.h"
5555
5556 /* FreeBSD K1OM support.  */
5557
5558 #undef  TARGET_LITTLE_SYM
5559 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_freebsd_vec
5560 #undef  TARGET_LITTLE_NAME
5561 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
5562
5563 #undef  ELF_OSABI
5564 #define ELF_OSABI                           ELFOSABI_FREEBSD
5565
5566 #undef  elf64_bed
5567 #define elf64_bed elf64_k1om_fbsd_bed
5568
5569 #include "elf64-target.h"
5570
5571 /* 32bit x86-64 support.  */
5572
5573 #undef  TARGET_LITTLE_SYM
5574 #define TARGET_LITTLE_SYM                   bfd_elf32_x86_64_vec
5575 #undef  TARGET_LITTLE_NAME
5576 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
5577 #undef  elf32_bed
5578
5579 #undef ELF_ARCH
5580 #define ELF_ARCH                            bfd_arch_i386
5581
5582 #undef  ELF_MACHINE_CODE
5583 #define ELF_MACHINE_CODE                    EM_X86_64
5584
5585 #undef  ELF_OSABI
5586
5587 #undef elf_backend_object_p
5588 #define elf_backend_object_p \
5589   elf32_x86_64_elf_object_p
5590
5591 #undef elf_backend_bfd_from_remote_memory
5592 #define elf_backend_bfd_from_remote_memory \
5593   _bfd_elf32_bfd_from_remote_memory
5594
5595 #undef elf_backend_size_info
5596 #define elf_backend_size_info \
5597   _bfd_elf32_size_info
5598
5599 #include "elf32-target.h"