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   /* Since pc_count for TLS symbol can only have size relocations and
2404      we always resolve size relocation against non-zero TLS symbol, we
2405      clear pc_count for non-zero TLS symbol.  */
2406   if (h->type == STT_TLS && h->size != 0)
2407     {
2408       struct elf_dyn_relocs **pp;
2409
2410       for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2411         {
2412           p->count -= p->pc_count;
2413           p->pc_count = 0;
2414           if (p->count == 0)
2415             *pp = p->next;
2416           else
2417             pp = &p->next;
2418         }
2419     }
2420
2421   /* In the shared -Bsymbolic case, discard space allocated for
2422      dynamic pc-relative relocs against symbols which turn out to be
2423      defined in regular objects.  For the normal shared case, discard
2424      space for pc-relative relocs that have become local due to symbol
2425      visibility changes.  */
2426
2427   if (info->shared)
2428     {
2429       /* Relocs that use pc_count are those that appear on a call
2430          insn, or certain REL relocs that can generated via assembly.
2431          We want calls to protected symbols to resolve directly to the
2432          function rather than going via the plt.  If people want
2433          function pointer comparisons to work as expected then they
2434          should avoid writing weird assembly.  */
2435       if (SYMBOL_CALLS_LOCAL (info, h))
2436         {
2437           struct elf_dyn_relocs **pp;
2438
2439           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2440             {
2441               p->count -= p->pc_count;
2442               p->pc_count = 0;
2443               if (p->count == 0)
2444                 *pp = p->next;
2445               else
2446                 pp = &p->next;
2447             }
2448         }
2449
2450       /* Also discard relocs on undefined weak syms with non-default
2451          visibility.  */
2452       if (eh->dyn_relocs != NULL
2453           && h->root.type == bfd_link_hash_undefweak)
2454         {
2455           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2456             eh->dyn_relocs = NULL;
2457
2458           /* Make sure undefined weak symbols are output as a dynamic
2459              symbol in PIEs.  */
2460           else if (h->dynindx == -1
2461                    && ! h->forced_local
2462                    && ! bfd_elf_link_record_dynamic_symbol (info, h))
2463             return FALSE;
2464         }
2465
2466     }
2467   else if (ELIMINATE_COPY_RELOCS)
2468     {
2469       /* For the non-shared case, discard space for relocs against
2470          symbols which turn out to need copy relocs or are not
2471          dynamic.  */
2472
2473       if (!h->non_got_ref
2474           && ((h->def_dynamic
2475                && !h->def_regular)
2476               || (htab->elf.dynamic_sections_created
2477                   && (h->root.type == bfd_link_hash_undefweak
2478                       || h->root.type == bfd_link_hash_undefined))))
2479         {
2480           /* Make sure this symbol is output as a dynamic symbol.
2481              Undefined weak syms won't yet be marked as dynamic.  */
2482           if (h->dynindx == -1
2483               && ! h->forced_local
2484               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2485             return FALSE;
2486
2487           /* If that succeeded, we know we'll be keeping all the
2488              relocs.  */
2489           if (h->dynindx != -1)
2490             goto keep;
2491         }
2492
2493       eh->dyn_relocs = NULL;
2494
2495     keep: ;
2496     }
2497
2498   /* Finally, allocate space.  */
2499   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2500     {
2501       asection * sreloc;
2502
2503       sreloc = elf_section_data (p->sec)->sreloc;
2504
2505       BFD_ASSERT (sreloc != NULL);
2506
2507       sreloc->size += p->count * bed->s->sizeof_rela;
2508     }
2509
2510   return TRUE;
2511 }
2512
2513 /* Allocate space in .plt, .got and associated reloc sections for
2514    local dynamic relocs.  */
2515
2516 static bfd_boolean
2517 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2518 {
2519   struct elf_link_hash_entry *h
2520     = (struct elf_link_hash_entry *) *slot;
2521
2522   if (h->type != STT_GNU_IFUNC
2523       || !h->def_regular
2524       || !h->ref_regular
2525       || !h->forced_local
2526       || h->root.type != bfd_link_hash_defined)
2527     abort ();
2528
2529   return elf_x86_64_allocate_dynrelocs (h, inf);
2530 }
2531
2532 /* Find any dynamic relocs that apply to read-only sections.  */
2533
2534 static bfd_boolean
2535 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2536                                void * inf)
2537 {
2538   struct elf_x86_64_link_hash_entry *eh;
2539   struct elf_dyn_relocs *p;
2540
2541   /* Skip local IFUNC symbols. */
2542   if (h->forced_local && h->type == STT_GNU_IFUNC)
2543     return TRUE;
2544
2545   eh = (struct elf_x86_64_link_hash_entry *) h;
2546   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2547     {
2548       asection *s = p->sec->output_section;
2549
2550       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2551         {
2552           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2553
2554           info->flags |= DF_TEXTREL;
2555
2556           if (info->warn_shared_textrel && info->shared)
2557             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2558                                     p->sec->owner, h->root.root.string,
2559                                     p->sec);
2560
2561           /* Not an error, just cut short the traversal.  */
2562           return FALSE;
2563         }
2564     }
2565   return TRUE;
2566 }
2567
2568 /* Convert
2569    mov foo@GOTPCREL(%rip), %reg
2570    to
2571    lea foo(%rip), %reg
2572    with the local symbol, foo.  */
2573
2574 static bfd_boolean
2575 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2576                                struct bfd_link_info *link_info)
2577 {
2578   Elf_Internal_Shdr *symtab_hdr;
2579   Elf_Internal_Rela *internal_relocs;
2580   Elf_Internal_Rela *irel, *irelend;
2581   bfd_byte *contents;
2582   struct elf_x86_64_link_hash_table *htab;
2583   bfd_boolean changed_contents;
2584   bfd_boolean changed_relocs;
2585   bfd_signed_vma *local_got_refcounts;
2586
2587   /* Don't even try to convert non-ELF outputs.  */
2588   if (!is_elf_hash_table (link_info->hash))
2589     return FALSE;
2590
2591   /* Nothing to do if there are no codes, no relocations or no output.  */
2592   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2593       || sec->reloc_count == 0
2594       || discarded_section (sec))
2595     return TRUE;
2596
2597   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2598
2599   /* Load the relocations for this section.  */
2600   internal_relocs = (_bfd_elf_link_read_relocs
2601                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2602                       link_info->keep_memory));
2603   if (internal_relocs == NULL)
2604     return FALSE;
2605
2606   htab = elf_x86_64_hash_table (link_info);
2607   changed_contents = FALSE;
2608   changed_relocs = FALSE;
2609   local_got_refcounts = elf_local_got_refcounts (abfd);
2610
2611   /* Get the section contents.  */
2612   if (elf_section_data (sec)->this_hdr.contents != NULL)
2613     contents = elf_section_data (sec)->this_hdr.contents;
2614   else
2615     {
2616       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2617         goto error_return;
2618     }
2619
2620   irelend = internal_relocs + sec->reloc_count;
2621   for (irel = internal_relocs; irel < irelend; irel++)
2622     {
2623       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2624       unsigned int r_symndx = htab->r_sym (irel->r_info);
2625       unsigned int indx;
2626       struct elf_link_hash_entry *h;
2627
2628       if (r_type != R_X86_64_GOTPCREL)
2629         continue;
2630
2631       /* Get the symbol referred to by the reloc.  */
2632       if (r_symndx < symtab_hdr->sh_info)
2633         {
2634           Elf_Internal_Sym *isym;
2635
2636           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2637                                         abfd, r_symndx);
2638
2639           /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation.  */
2640           if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2641               && bfd_get_8 (input_bfd,
2642                             contents + irel->r_offset - 2) == 0x8b)
2643             {
2644               bfd_put_8 (output_bfd, 0x8d,
2645                          contents + irel->r_offset - 2);
2646               irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2647               if (local_got_refcounts != NULL
2648                   && local_got_refcounts[r_symndx] > 0)
2649                 local_got_refcounts[r_symndx] -= 1;
2650               changed_contents = TRUE;
2651               changed_relocs = TRUE;
2652             }
2653           continue;
2654         }
2655
2656       indx = r_symndx - symtab_hdr->sh_info;
2657       h = elf_sym_hashes (abfd)[indx];
2658       BFD_ASSERT (h != NULL);
2659
2660       while (h->root.type == bfd_link_hash_indirect
2661              || h->root.type == bfd_link_hash_warning)
2662         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2663
2664       /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation.  We also
2665          avoid optimizing _DYNAMIC since ld.so may use its link-time
2666          address.  */
2667       if (h->def_regular
2668           && h->type != STT_GNU_IFUNC
2669           && h != htab->elf.hdynamic
2670           && SYMBOL_REFERENCES_LOCAL (link_info, h)
2671           && bfd_get_8 (input_bfd,
2672                         contents + irel->r_offset - 2) == 0x8b)
2673         {
2674           bfd_put_8 (output_bfd, 0x8d,
2675                      contents + irel->r_offset - 2);
2676           irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2677           if (h->got.refcount > 0)
2678             h->got.refcount -= 1;
2679           changed_contents = TRUE;
2680           changed_relocs = TRUE;
2681         }
2682     }
2683
2684   if (contents != NULL
2685       && elf_section_data (sec)->this_hdr.contents != contents)
2686     {
2687       if (!changed_contents && !link_info->keep_memory)
2688         free (contents);
2689       else
2690         {
2691           /* Cache the section contents for elf_link_input_bfd.  */
2692           elf_section_data (sec)->this_hdr.contents = contents;
2693         }
2694     }
2695
2696   if (elf_section_data (sec)->relocs != internal_relocs)
2697     {
2698       if (!changed_relocs)
2699         free (internal_relocs);
2700       else
2701         elf_section_data (sec)->relocs = internal_relocs;
2702     }
2703
2704   return TRUE;
2705
2706  error_return:
2707   if (contents != NULL
2708       && elf_section_data (sec)->this_hdr.contents != contents)
2709     free (contents);
2710   if (internal_relocs != NULL
2711       && elf_section_data (sec)->relocs != internal_relocs)
2712     free (internal_relocs);
2713   return FALSE;
2714 }
2715
2716 /* Set the sizes of the dynamic sections.  */
2717
2718 static bfd_boolean
2719 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2720                                   struct bfd_link_info *info)
2721 {
2722   struct elf_x86_64_link_hash_table *htab;
2723   bfd *dynobj;
2724   asection *s;
2725   bfd_boolean relocs;
2726   bfd *ibfd;
2727   const struct elf_backend_data *bed;
2728
2729   htab = elf_x86_64_hash_table (info);
2730   if (htab == NULL)
2731     return FALSE;
2732   bed = get_elf_backend_data (output_bfd);
2733
2734   dynobj = htab->elf.dynobj;
2735   if (dynobj == NULL)
2736     abort ();
2737
2738   if (htab->elf.dynamic_sections_created)
2739     {
2740       /* Set the contents of the .interp section to the interpreter.  */
2741       if (info->executable)
2742         {
2743           s = bfd_get_linker_section (dynobj, ".interp");
2744           if (s == NULL)
2745             abort ();
2746           s->size = htab->dynamic_interpreter_size;
2747           s->contents = (unsigned char *) htab->dynamic_interpreter;
2748         }
2749     }
2750
2751   /* Set up .got offsets for local syms, and space for local dynamic
2752      relocs.  */
2753   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2754     {
2755       bfd_signed_vma *local_got;
2756       bfd_signed_vma *end_local_got;
2757       char *local_tls_type;
2758       bfd_vma *local_tlsdesc_gotent;
2759       bfd_size_type locsymcount;
2760       Elf_Internal_Shdr *symtab_hdr;
2761       asection *srel;
2762
2763       if (! is_x86_64_elf (ibfd))
2764         continue;
2765
2766       for (s = ibfd->sections; s != NULL; s = s->next)
2767         {
2768           struct elf_dyn_relocs *p;
2769
2770           if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2771             return FALSE;
2772
2773           for (p = (struct elf_dyn_relocs *)
2774                     (elf_section_data (s)->local_dynrel);
2775                p != NULL;
2776                p = p->next)
2777             {
2778               if (!bfd_is_abs_section (p->sec)
2779                   && bfd_is_abs_section (p->sec->output_section))
2780                 {
2781                   /* Input section has been discarded, either because
2782                      it is a copy of a linkonce section or due to
2783                      linker script /DISCARD/, so we'll be discarding
2784                      the relocs too.  */
2785                 }
2786               else if (p->count != 0)
2787                 {
2788                   srel = elf_section_data (p->sec)->sreloc;
2789                   srel->size += p->count * bed->s->sizeof_rela;
2790                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2791                       && (info->flags & DF_TEXTREL) == 0)
2792                     {
2793                       info->flags |= DF_TEXTREL;
2794                       if (info->warn_shared_textrel && info->shared)
2795                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2796                                                 p->sec->owner, p->sec);
2797                     }
2798                 }
2799             }
2800         }
2801
2802       local_got = elf_local_got_refcounts (ibfd);
2803       if (!local_got)
2804         continue;
2805
2806       symtab_hdr = &elf_symtab_hdr (ibfd);
2807       locsymcount = symtab_hdr->sh_info;
2808       end_local_got = local_got + locsymcount;
2809       local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2810       local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2811       s = htab->elf.sgot;
2812       srel = htab->elf.srelgot;
2813       for (; local_got < end_local_got;
2814            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2815         {
2816           *local_tlsdesc_gotent = (bfd_vma) -1;
2817           if (*local_got > 0)
2818             {
2819               if (GOT_TLS_GDESC_P (*local_tls_type))
2820                 {
2821                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2822                     - elf_x86_64_compute_jump_table_size (htab);
2823                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2824                   *local_got = (bfd_vma) -2;
2825                 }
2826               if (! GOT_TLS_GDESC_P (*local_tls_type)
2827                   || GOT_TLS_GD_P (*local_tls_type))
2828                 {
2829                   *local_got = s->size;
2830                   s->size += GOT_ENTRY_SIZE;
2831                   if (GOT_TLS_GD_P (*local_tls_type))
2832                     s->size += GOT_ENTRY_SIZE;
2833                 }
2834               if (info->shared
2835                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2836                   || *local_tls_type == GOT_TLS_IE)
2837                 {
2838                   if (GOT_TLS_GDESC_P (*local_tls_type))
2839                     {
2840                       htab->elf.srelplt->size
2841                         += bed->s->sizeof_rela;
2842                       htab->tlsdesc_plt = (bfd_vma) -1;
2843                     }
2844                   if (! GOT_TLS_GDESC_P (*local_tls_type)
2845                       || GOT_TLS_GD_P (*local_tls_type))
2846                     srel->size += bed->s->sizeof_rela;
2847                 }
2848             }
2849           else
2850             *local_got = (bfd_vma) -1;
2851         }
2852     }
2853
2854   if (htab->tls_ld_got.refcount > 0)
2855     {
2856       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2857          relocs.  */
2858       htab->tls_ld_got.offset = htab->elf.sgot->size;
2859       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2860       htab->elf.srelgot->size += bed->s->sizeof_rela;
2861     }
2862   else
2863     htab->tls_ld_got.offset = -1;
2864
2865   /* Allocate global sym .plt and .got entries, and space for global
2866      sym dynamic relocs.  */
2867   elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2868                           info);
2869
2870   /* Allocate .plt and .got entries, and space for local symbols.  */
2871   htab_traverse (htab->loc_hash_table,
2872                  elf_x86_64_allocate_local_dynrelocs,
2873                  info);
2874
2875   /* For every jump slot reserved in the sgotplt, reloc_count is
2876      incremented.  However, when we reserve space for TLS descriptors,
2877      it's not incremented, so in order to compute the space reserved
2878      for them, it suffices to multiply the reloc count by the jump
2879      slot size.
2880
2881      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2882      so that R_X86_64_IRELATIVE entries come last.  */
2883   if (htab->elf.srelplt)
2884     {
2885       htab->sgotplt_jump_table_size
2886         = elf_x86_64_compute_jump_table_size (htab);
2887       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2888     }
2889   else if (htab->elf.irelplt)
2890     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2891
2892   if (htab->tlsdesc_plt)
2893     {
2894       /* If we're not using lazy TLS relocations, don't generate the
2895          PLT and GOT entries they require.  */
2896       if ((info->flags & DF_BIND_NOW))
2897         htab->tlsdesc_plt = 0;
2898       else
2899         {
2900           htab->tlsdesc_got = htab->elf.sgot->size;
2901           htab->elf.sgot->size += GOT_ENTRY_SIZE;
2902           /* Reserve room for the initial entry.
2903              FIXME: we could probably do away with it in this case.  */
2904           if (htab->elf.splt->size == 0)
2905             htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2906           htab->tlsdesc_plt = htab->elf.splt->size;
2907           htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2908         }
2909     }
2910
2911   if (htab->elf.sgotplt)
2912     {
2913       /* Don't allocate .got.plt section if there are no GOT nor PLT
2914          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2915       if ((htab->elf.hgot == NULL
2916            || !htab->elf.hgot->ref_regular_nonweak)
2917           && (htab->elf.sgotplt->size
2918               == get_elf_backend_data (output_bfd)->got_header_size)
2919           && (htab->elf.splt == NULL
2920               || htab->elf.splt->size == 0)
2921           && (htab->elf.sgot == NULL
2922               || htab->elf.sgot->size == 0)
2923           && (htab->elf.iplt == NULL
2924               || htab->elf.iplt->size == 0)
2925           && (htab->elf.igotplt == NULL
2926               || htab->elf.igotplt->size == 0))
2927         htab->elf.sgotplt->size = 0;
2928     }
2929
2930   if (htab->plt_eh_frame != NULL
2931       && htab->elf.splt != NULL
2932       && htab->elf.splt->size != 0
2933       && !bfd_is_abs_section (htab->elf.splt->output_section)
2934       && _bfd_elf_eh_frame_present (info))
2935     {
2936       const struct elf_x86_64_backend_data *arch_data
2937         = (const struct elf_x86_64_backend_data *) bed->arch_data;
2938       htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2939     }
2940
2941   /* We now have determined the sizes of the various dynamic sections.
2942      Allocate memory for them.  */
2943   relocs = FALSE;
2944   for (s = dynobj->sections; s != NULL; s = s->next)
2945     {
2946       if ((s->flags & SEC_LINKER_CREATED) == 0)
2947         continue;
2948
2949       if (s == htab->elf.splt
2950           || s == htab->elf.sgot
2951           || s == htab->elf.sgotplt
2952           || s == htab->elf.iplt
2953           || s == htab->elf.igotplt
2954           || s == htab->plt_eh_frame
2955           || s == htab->sdynbss)
2956         {
2957           /* Strip this section if we don't need it; see the
2958              comment below.  */
2959         }
2960       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2961         {
2962           if (s->size != 0 && s != htab->elf.srelplt)
2963             relocs = TRUE;
2964
2965           /* We use the reloc_count field as a counter if we need
2966              to copy relocs into the output file.  */
2967           if (s != htab->elf.srelplt)
2968             s->reloc_count = 0;
2969         }
2970       else
2971         {
2972           /* It's not one of our sections, so don't allocate space.  */
2973           continue;
2974         }
2975
2976       if (s->size == 0)
2977         {
2978           /* If we don't need this section, strip it from the
2979              output file.  This is mostly to handle .rela.bss and
2980              .rela.plt.  We must create both sections in
2981              create_dynamic_sections, because they must be created
2982              before the linker maps input sections to output
2983              sections.  The linker does that before
2984              adjust_dynamic_symbol is called, and it is that
2985              function which decides whether anything needs to go
2986              into these sections.  */
2987
2988           s->flags |= SEC_EXCLUDE;
2989           continue;
2990         }
2991
2992       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2993         continue;
2994
2995       /* Allocate memory for the section contents.  We use bfd_zalloc
2996          here in case unused entries are not reclaimed before the
2997          section's contents are written out.  This should not happen,
2998          but this way if it does, we get a R_X86_64_NONE reloc instead
2999          of garbage.  */
3000       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3001       if (s->contents == NULL)
3002         return FALSE;
3003     }
3004
3005   if (htab->plt_eh_frame != NULL
3006       && htab->plt_eh_frame->contents != NULL)
3007     {
3008       const struct elf_x86_64_backend_data *arch_data
3009         = (const struct elf_x86_64_backend_data *) bed->arch_data;
3010
3011       memcpy (htab->plt_eh_frame->contents,
3012               arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3013       bfd_put_32 (dynobj, htab->elf.splt->size,
3014                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3015     }
3016
3017   if (htab->elf.dynamic_sections_created)
3018     {
3019       /* Add some entries to the .dynamic section.  We fill in the
3020          values later, in elf_x86_64_finish_dynamic_sections, but we
3021          must add the entries now so that we get the correct size for
3022          the .dynamic section.  The DT_DEBUG entry is filled in by the
3023          dynamic linker and used by the debugger.  */
3024 #define add_dynamic_entry(TAG, VAL) \
3025   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3026
3027       if (info->executable)
3028         {
3029           if (!add_dynamic_entry (DT_DEBUG, 0))
3030             return FALSE;
3031         }
3032
3033       if (htab->elf.splt->size != 0)
3034         {
3035           if (!add_dynamic_entry (DT_PLTGOT, 0)
3036               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3037               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3038               || !add_dynamic_entry (DT_JMPREL, 0))
3039             return FALSE;
3040
3041           if (htab->tlsdesc_plt
3042               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3043                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3044             return FALSE;
3045         }
3046
3047       if (relocs)
3048         {
3049           if (!add_dynamic_entry (DT_RELA, 0)
3050               || !add_dynamic_entry (DT_RELASZ, 0)
3051               || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3052             return FALSE;
3053
3054           /* If any dynamic relocs apply to a read-only section,
3055              then we need a DT_TEXTREL entry.  */
3056           if ((info->flags & DF_TEXTREL) == 0)
3057             elf_link_hash_traverse (&htab->elf,
3058                                     elf_x86_64_readonly_dynrelocs,
3059                                     info);
3060
3061           if ((info->flags & DF_TEXTREL) != 0)
3062             {
3063               if (!add_dynamic_entry (DT_TEXTREL, 0))
3064                 return FALSE;
3065             }
3066         }
3067     }
3068 #undef add_dynamic_entry
3069
3070   return TRUE;
3071 }
3072
3073 static bfd_boolean
3074 elf_x86_64_always_size_sections (bfd *output_bfd,
3075                                  struct bfd_link_info *info)
3076 {
3077   asection *tls_sec = elf_hash_table (info)->tls_sec;
3078
3079   if (tls_sec)
3080     {
3081       struct elf_link_hash_entry *tlsbase;
3082
3083       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3084                                       "_TLS_MODULE_BASE_",
3085                                       FALSE, FALSE, FALSE);
3086
3087       if (tlsbase && tlsbase->type == STT_TLS)
3088         {
3089           struct elf_x86_64_link_hash_table *htab;
3090           struct bfd_link_hash_entry *bh = NULL;
3091           const struct elf_backend_data *bed
3092             = get_elf_backend_data (output_bfd);
3093
3094           htab = elf_x86_64_hash_table (info);
3095           if (htab == NULL)
3096             return FALSE;
3097
3098           if (!(_bfd_generic_link_add_one_symbol
3099                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3100                  tls_sec, 0, NULL, FALSE,
3101                  bed->collect, &bh)))
3102             return FALSE;
3103
3104           htab->tls_module_base = bh;
3105
3106           tlsbase = (struct elf_link_hash_entry *)bh;
3107           tlsbase->def_regular = 1;
3108           tlsbase->other = STV_HIDDEN;
3109           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3110         }
3111     }
3112
3113   return TRUE;
3114 }
3115
3116 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3117    executables.  Rather than setting it to the beginning of the TLS
3118    section, we have to set it to the end.  This function may be called
3119    multiple times, it is idempotent.  */
3120
3121 static void
3122 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3123 {
3124   struct elf_x86_64_link_hash_table *htab;
3125   struct bfd_link_hash_entry *base;
3126
3127   if (!info->executable)
3128     return;
3129
3130   htab = elf_x86_64_hash_table (info);
3131   if (htab == NULL)
3132     return;
3133
3134   base = htab->tls_module_base;
3135   if (base == NULL)
3136     return;
3137
3138   base->u.def.value = htab->elf.tls_size;
3139 }
3140
3141 /* Return the base VMA address which should be subtracted from real addresses
3142    when resolving @dtpoff relocation.
3143    This is PT_TLS segment p_vaddr.  */
3144
3145 static bfd_vma
3146 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3147 {
3148   /* If tls_sec is NULL, we should have signalled an error already.  */
3149   if (elf_hash_table (info)->tls_sec == NULL)
3150     return 0;
3151   return elf_hash_table (info)->tls_sec->vma;
3152 }
3153
3154 /* Return the relocation value for @tpoff relocation
3155    if STT_TLS virtual address is ADDRESS.  */
3156
3157 static bfd_vma
3158 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3159 {
3160   struct elf_link_hash_table *htab = elf_hash_table (info);
3161   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3162   bfd_vma static_tls_size;
3163
3164   /* If tls_segment is NULL, we should have signalled an error already.  */
3165   if (htab->tls_sec == NULL)
3166     return 0;
3167
3168   /* Consider special static TLS alignment requirements.  */
3169   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3170   return address - static_tls_size - htab->tls_sec->vma;
3171 }
3172
3173 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3174    branch?  */
3175
3176 static bfd_boolean
3177 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3178 {
3179   /* Opcode             Instruction
3180      0xe8               call
3181      0xe9               jump
3182      0x0f 0x8x          conditional jump */
3183   return ((offset > 0
3184            && (contents [offset - 1] == 0xe8
3185                || contents [offset - 1] == 0xe9))
3186           || (offset > 1
3187               && contents [offset - 2] == 0x0f
3188               && (contents [offset - 1] & 0xf0) == 0x80));
3189 }
3190
3191 /* Relocate an x86_64 ELF section.  */
3192
3193 static bfd_boolean
3194 elf_x86_64_relocate_section (bfd *output_bfd,
3195                              struct bfd_link_info *info,
3196                              bfd *input_bfd,
3197                              asection *input_section,
3198                              bfd_byte *contents,
3199                              Elf_Internal_Rela *relocs,
3200                              Elf_Internal_Sym *local_syms,
3201                              asection **local_sections)
3202 {
3203   struct elf_x86_64_link_hash_table *htab;
3204   Elf_Internal_Shdr *symtab_hdr;
3205   struct elf_link_hash_entry **sym_hashes;
3206   bfd_vma *local_got_offsets;
3207   bfd_vma *local_tlsdesc_gotents;
3208   Elf_Internal_Rela *rel;
3209   Elf_Internal_Rela *relend;
3210   const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3211
3212   BFD_ASSERT (is_x86_64_elf (input_bfd));
3213
3214   htab = elf_x86_64_hash_table (info);
3215   if (htab == NULL)
3216     return FALSE;
3217   symtab_hdr = &elf_symtab_hdr (input_bfd);
3218   sym_hashes = elf_sym_hashes (input_bfd);
3219   local_got_offsets = elf_local_got_offsets (input_bfd);
3220   local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3221
3222   elf_x86_64_set_tls_module_base (info);
3223
3224   rel = relocs;
3225   relend = relocs + input_section->reloc_count;
3226   for (; rel < relend; rel++)
3227     {
3228       unsigned int r_type;
3229       reloc_howto_type *howto;
3230       unsigned long r_symndx;
3231       struct elf_link_hash_entry *h;
3232       Elf_Internal_Sym *sym;
3233       asection *sec;
3234       bfd_vma off, offplt;
3235       bfd_vma relocation;
3236       bfd_boolean unresolved_reloc;
3237       bfd_reloc_status_type r;
3238       int tls_type;
3239       asection *base_got;
3240       bfd_vma st_size;
3241
3242       r_type = ELF32_R_TYPE (rel->r_info);
3243       if (r_type == (int) R_X86_64_GNU_VTINHERIT
3244           || r_type == (int) R_X86_64_GNU_VTENTRY)
3245         continue;
3246
3247       if (r_type >= (int) R_X86_64_standard)
3248         {
3249           (*_bfd_error_handler)
3250             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3251              input_bfd, input_section, r_type);
3252           bfd_set_error (bfd_error_bad_value);
3253           return FALSE;
3254         }
3255
3256       if (r_type != (int) R_X86_64_32
3257           || ABI_64_P (output_bfd))
3258         howto = x86_64_elf_howto_table + r_type;
3259       else
3260         howto = (x86_64_elf_howto_table
3261                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3262       r_symndx = htab->r_sym (rel->r_info);
3263       h = NULL;
3264       sym = NULL;
3265       sec = NULL;
3266       unresolved_reloc = FALSE;
3267       if (r_symndx < symtab_hdr->sh_info)
3268         {
3269           sym = local_syms + r_symndx;
3270           sec = local_sections[r_symndx];
3271
3272           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3273                                                 &sec, rel);
3274           st_size = sym->st_size;
3275
3276           /* Relocate against local STT_GNU_IFUNC symbol.  */
3277           if (!info->relocatable
3278               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3279             {
3280               h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3281                                                  rel, FALSE);
3282               if (h == NULL)
3283                 abort ();
3284
3285               /* Set STT_GNU_IFUNC symbol value.  */
3286               h->root.u.def.value = sym->st_value;
3287               h->root.u.def.section = sec;
3288             }
3289         }
3290       else
3291         {
3292           bfd_boolean warned ATTRIBUTE_UNUSED;
3293
3294           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3295                                    r_symndx, symtab_hdr, sym_hashes,
3296                                    h, sec, relocation,
3297                                    unresolved_reloc, warned);
3298           st_size = h->size;
3299         }
3300
3301       if (sec != NULL && discarded_section (sec))
3302         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3303                                          rel, 1, relend, howto, 0, contents);
3304
3305       if (info->relocatable)
3306         continue;
3307
3308       if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3309         {
3310           if (r_type == R_X86_64_64)
3311             {
3312               /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3313                  zero-extend it to 64bit if addend is zero.  */
3314               r_type = R_X86_64_32;
3315               memset (contents + rel->r_offset + 4, 0, 4);
3316             }
3317           else if (r_type == R_X86_64_SIZE64)
3318             {
3319               /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3320                  zero-extend it to 64bit if addend is zero.  */
3321               r_type = R_X86_64_SIZE32;
3322               memset (contents + rel->r_offset + 4, 0, 4);
3323             }
3324         }
3325
3326       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3327          it here if it is defined in a non-shared object.  */
3328       if (h != NULL
3329           && h->type == STT_GNU_IFUNC
3330           && h->def_regular)
3331         {
3332           asection *plt;
3333           bfd_vma plt_index;
3334           const char *name;
3335
3336           if ((input_section->flags & SEC_ALLOC) == 0
3337               || h->plt.offset == (bfd_vma) -1)
3338             abort ();
3339
3340           /* STT_GNU_IFUNC symbol must go through PLT.  */
3341           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3342           relocation = (plt->output_section->vma
3343                         + plt->output_offset + h->plt.offset);
3344
3345           switch (r_type)
3346             {
3347             default:
3348               if (h->root.root.string)
3349                 name = h->root.root.string;
3350               else
3351                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3352                                          NULL);
3353               (*_bfd_error_handler)
3354                 (_("%B: relocation %s against STT_GNU_IFUNC "
3355                    "symbol `%s' isn't handled by %s"), input_bfd,
3356                  x86_64_elf_howto_table[r_type].name,
3357                  name, __FUNCTION__);
3358               bfd_set_error (bfd_error_bad_value);
3359               return FALSE;
3360
3361             case R_X86_64_32S:
3362               if (info->shared)
3363                 abort ();
3364               goto do_relocation;
3365
3366             case R_X86_64_32:
3367               if (ABI_64_P (output_bfd))
3368                 goto do_relocation;
3369               /* FALLTHROUGH */
3370             case R_X86_64_64:
3371               if (rel->r_addend != 0)
3372                 {
3373                   if (h->root.root.string)
3374                     name = h->root.root.string;
3375                   else
3376                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3377                                              sym, NULL);
3378                   (*_bfd_error_handler)
3379                     (_("%B: relocation %s against STT_GNU_IFUNC "
3380                        "symbol `%s' has non-zero addend: %d"),
3381                      input_bfd, x86_64_elf_howto_table[r_type].name,
3382                      name, rel->r_addend);
3383                   bfd_set_error (bfd_error_bad_value);
3384                   return FALSE;
3385                 }
3386
3387               /* Generate dynamic relcoation only when there is a
3388                  non-GOT reference in a shared object.  */
3389               if (info->shared && h->non_got_ref)
3390                 {
3391                   Elf_Internal_Rela outrel;
3392                   asection *sreloc;
3393
3394                   /* Need a dynamic relocation to get the real function
3395                      address.  */
3396                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3397                                                              info,
3398                                                              input_section,
3399                                                              rel->r_offset);
3400                   if (outrel.r_offset == (bfd_vma) -1
3401                       || outrel.r_offset == (bfd_vma) -2)
3402                     abort ();
3403
3404                   outrel.r_offset += (input_section->output_section->vma
3405                                       + input_section->output_offset);
3406
3407                   if (h->dynindx == -1
3408                       || h->forced_local
3409                       || info->executable)
3410                     {
3411                       /* This symbol is resolved locally.  */
3412                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3413                       outrel.r_addend = (h->root.u.def.value
3414                                          + h->root.u.def.section->output_section->vma
3415                                          + h->root.u.def.section->output_offset);
3416                     }
3417                   else
3418                     {
3419                       outrel.r_info = htab->r_info (h->dynindx, r_type);
3420                       outrel.r_addend = 0;
3421                     }
3422
3423                   sreloc = htab->elf.irelifunc;
3424                   elf_append_rela (output_bfd, sreloc, &outrel);
3425
3426                   /* If this reloc is against an external symbol, we
3427                      do not want to fiddle with the addend.  Otherwise,
3428                      we need to include the symbol value so that it
3429                      becomes an addend for the dynamic reloc.  For an
3430                      internal symbol, we have updated addend.  */
3431                   continue;
3432                 }
3433               /* FALLTHROUGH */
3434             case R_X86_64_PC32:
3435             case R_X86_64_PC64:
3436             case R_X86_64_PLT32:
3437               goto do_relocation;
3438
3439             case R_X86_64_GOTPCREL:
3440             case R_X86_64_GOTPCREL64:
3441               base_got = htab->elf.sgot;
3442               off = h->got.offset;
3443
3444               if (base_got == NULL)
3445                 abort ();
3446
3447               if (off == (bfd_vma) -1)
3448                 {
3449                   /* We can't use h->got.offset here to save state, or
3450                      even just remember the offset, as finish_dynamic_symbol
3451                      would use that as offset into .got.  */
3452
3453                   if (htab->elf.splt != NULL)
3454                     {
3455                       plt_index = h->plt.offset / plt_entry_size - 1;
3456                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
3457                       base_got = htab->elf.sgotplt;
3458                     }
3459                   else
3460                     {
3461                       plt_index = h->plt.offset / plt_entry_size;
3462                       off = plt_index * GOT_ENTRY_SIZE;
3463                       base_got = htab->elf.igotplt;
3464                     }
3465
3466                   if (h->dynindx == -1
3467                       || h->forced_local
3468                       || info->symbolic)
3469                     {
3470                       /* This references the local defitionion.  We must
3471                          initialize this entry in the global offset table.
3472                          Since the offset must always be a multiple of 8,
3473                          we use the least significant bit to record
3474                          whether we have initialized it already.
3475
3476                          When doing a dynamic link, we create a .rela.got
3477                          relocation entry to initialize the value.  This
3478                          is done in the finish_dynamic_symbol routine.   */
3479                       if ((off & 1) != 0)
3480                         off &= ~1;
3481                       else
3482                         {
3483                           bfd_put_64 (output_bfd, relocation,
3484                                       base_got->contents + off);
3485                           /* Note that this is harmless for the GOTPLT64
3486                              case, as -1 | 1 still is -1.  */
3487                           h->got.offset |= 1;
3488                         }
3489                     }
3490                 }
3491
3492               relocation = (base_got->output_section->vma
3493                             + base_got->output_offset + off);
3494
3495               goto do_relocation;
3496             }
3497         }
3498
3499       /* When generating a shared object, the relocations handled here are
3500          copied into the output file to be resolved at run time.  */
3501       switch (r_type)
3502         {
3503         case R_X86_64_GOT32:
3504         case R_X86_64_GOT64:
3505           /* Relocation is to the entry for this symbol in the global
3506              offset table.  */
3507         case R_X86_64_GOTPCREL:
3508         case R_X86_64_GOTPCREL64:
3509           /* Use global offset table entry as symbol value.  */
3510         case R_X86_64_GOTPLT64:
3511           /* This is the same as GOT64 for relocation purposes, but
3512              indicates the existence of a PLT entry.  The difficulty is,
3513              that we must calculate the GOT slot offset from the PLT
3514              offset, if this symbol got a PLT entry (it was global).
3515              Additionally if it's computed from the PLT entry, then that
3516              GOT offset is relative to .got.plt, not to .got.  */
3517           base_got = htab->elf.sgot;
3518
3519           if (htab->elf.sgot == NULL)
3520             abort ();
3521
3522           if (h != NULL)
3523             {
3524               bfd_boolean dyn;
3525
3526               off = h->got.offset;
3527               if (h->needs_plt
3528                   && h->plt.offset != (bfd_vma)-1
3529                   && off == (bfd_vma)-1)
3530                 {
3531                   /* We can't use h->got.offset here to save
3532                      state, or even just remember the offset, as
3533                      finish_dynamic_symbol would use that as offset into
3534                      .got.  */
3535                   bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3536                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
3537                   base_got = htab->elf.sgotplt;
3538                 }
3539
3540               dyn = htab->elf.dynamic_sections_created;
3541
3542               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3543                   || (info->shared
3544                       && SYMBOL_REFERENCES_LOCAL (info, h))
3545                   || (ELF_ST_VISIBILITY (h->other)
3546                       && h->root.type == bfd_link_hash_undefweak))
3547                 {
3548                   /* This is actually a static link, or it is a -Bsymbolic
3549                      link and the symbol is defined locally, or the symbol
3550                      was forced to be local because of a version file.  We
3551                      must initialize this entry in the global offset table.
3552                      Since the offset must always be a multiple of 8, we
3553                      use the least significant bit to record whether we
3554                      have initialized it already.
3555
3556                      When doing a dynamic link, we create a .rela.got
3557                      relocation entry to initialize the value.  This is
3558                      done in the finish_dynamic_symbol routine.  */
3559                   if ((off & 1) != 0)
3560                     off &= ~1;
3561                   else
3562                     {
3563                       bfd_put_64 (output_bfd, relocation,
3564                                   base_got->contents + off);
3565                       /* Note that this is harmless for the GOTPLT64 case,
3566                          as -1 | 1 still is -1.  */
3567                       h->got.offset |= 1;
3568                     }
3569                 }
3570               else
3571                 unresolved_reloc = FALSE;
3572             }
3573           else
3574             {
3575               if (local_got_offsets == NULL)
3576                 abort ();
3577
3578               off = local_got_offsets[r_symndx];
3579
3580               /* The offset must always be a multiple of 8.  We use
3581                  the least significant bit to record whether we have
3582                  already generated the necessary reloc.  */
3583               if ((off & 1) != 0)
3584                 off &= ~1;
3585               else
3586                 {
3587                   bfd_put_64 (output_bfd, relocation,
3588                               base_got->contents + off);
3589
3590                   if (info->shared)
3591                     {
3592                       asection *s;
3593                       Elf_Internal_Rela outrel;
3594
3595                       /* We need to generate a R_X86_64_RELATIVE reloc
3596                          for the dynamic linker.  */
3597                       s = htab->elf.srelgot;
3598                       if (s == NULL)
3599                         abort ();
3600
3601                       outrel.r_offset = (base_got->output_section->vma
3602                                          + base_got->output_offset
3603                                          + off);
3604                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3605                       outrel.r_addend = relocation;
3606                       elf_append_rela (output_bfd, s, &outrel);
3607                     }
3608
3609                   local_got_offsets[r_symndx] |= 1;
3610                 }
3611             }
3612
3613           if (off >= (bfd_vma) -2)
3614             abort ();
3615
3616           relocation = base_got->output_section->vma
3617                        + base_got->output_offset + off;
3618           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3619             relocation -= htab->elf.sgotplt->output_section->vma
3620                           - htab->elf.sgotplt->output_offset;
3621
3622           break;
3623
3624         case R_X86_64_GOTOFF64:
3625           /* Relocation is relative to the start of the global offset
3626              table.  */
3627
3628           /* Check to make sure it isn't a protected function symbol
3629              for shared library since it may not be local when used
3630              as function address.  */
3631           if (!info->executable
3632               && h
3633               && !SYMBOLIC_BIND (info, h)
3634               && h->def_regular
3635               && h->type == STT_FUNC
3636               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3637             {
3638               (*_bfd_error_handler)
3639                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3640                  input_bfd, h->root.root.string);
3641               bfd_set_error (bfd_error_bad_value);
3642               return FALSE;
3643             }
3644
3645           /* Note that sgot is not involved in this
3646              calculation.  We always want the start of .got.plt.  If we
3647              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3648              permitted by the ABI, we might have to change this
3649              calculation.  */
3650           relocation -= htab->elf.sgotplt->output_section->vma
3651                         + htab->elf.sgotplt->output_offset;
3652           break;
3653
3654         case R_X86_64_GOTPC32:
3655         case R_X86_64_GOTPC64:
3656           /* Use global offset table as symbol value.  */
3657           relocation = htab->elf.sgotplt->output_section->vma
3658                        + htab->elf.sgotplt->output_offset;
3659           unresolved_reloc = FALSE;
3660           break;
3661
3662         case R_X86_64_PLTOFF64:
3663           /* Relocation is PLT entry relative to GOT.  For local
3664              symbols it's the symbol itself relative to GOT.  */
3665           if (h != NULL
3666               /* See PLT32 handling.  */
3667               && h->plt.offset != (bfd_vma) -1
3668               && htab->elf.splt != NULL)
3669             {
3670               relocation = (htab->elf.splt->output_section->vma
3671                             + htab->elf.splt->output_offset
3672                             + h->plt.offset);
3673               unresolved_reloc = FALSE;
3674             }
3675
3676           relocation -= htab->elf.sgotplt->output_section->vma
3677                         + htab->elf.sgotplt->output_offset;
3678           break;
3679
3680         case R_X86_64_PLT32:
3681           /* Relocation is to the entry for this symbol in the
3682              procedure linkage table.  */
3683
3684           /* Resolve a PLT32 reloc against a local symbol directly,
3685              without using the procedure linkage table.  */
3686           if (h == NULL)
3687             break;
3688
3689           if (h->plt.offset == (bfd_vma) -1
3690               || htab->elf.splt == NULL)
3691             {
3692               /* We didn't make a PLT entry for this symbol.  This
3693                  happens when statically linking PIC code, or when
3694                  using -Bsymbolic.  */
3695               break;
3696             }
3697
3698           relocation = (htab->elf.splt->output_section->vma
3699                         + htab->elf.splt->output_offset
3700                         + h->plt.offset);
3701           unresolved_reloc = FALSE;
3702           break;
3703
3704         case R_X86_64_SIZE32:
3705         case R_X86_64_SIZE64:
3706           /* Set to symbol size.  */
3707           relocation = st_size;
3708           if (h && h->type == STT_TLS && st_size != 0)
3709             {
3710               /* Resolve size relocation against non-zero TLS symbol.  */
3711               unresolved_reloc = FALSE;
3712               break;
3713             }
3714           goto direct;
3715
3716         case R_X86_64_PC8:
3717         case R_X86_64_PC16:
3718         case R_X86_64_PC32:
3719           if (info->shared
3720               && (input_section->flags & SEC_ALLOC) != 0
3721               && (input_section->flags & SEC_READONLY) != 0
3722               && h != NULL)
3723             {
3724               bfd_boolean fail = FALSE;
3725               bfd_boolean branch
3726                 = (r_type == R_X86_64_PC32
3727                    && is_32bit_relative_branch (contents, rel->r_offset));
3728
3729               if (SYMBOL_REFERENCES_LOCAL (info, h))
3730                 {
3731                   /* Symbol is referenced locally.  Make sure it is
3732                      defined locally or for a branch.  */
3733                   fail = !h->def_regular && !branch;
3734                 }
3735               else
3736                 {
3737                   /* Symbol isn't referenced locally.  We only allow
3738                      branch to symbol with non-default visibility. */
3739                   fail = (!branch
3740                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3741                 }
3742
3743               if (fail)
3744                 {
3745                   const char *fmt;
3746                   const char *v;
3747                   const char *pic = "";
3748
3749                   switch (ELF_ST_VISIBILITY (h->other))
3750                     {
3751                     case STV_HIDDEN:
3752                       v = _("hidden symbol");
3753                       break;
3754                     case STV_INTERNAL:
3755                       v = _("internal symbol");
3756                       break;
3757                     case STV_PROTECTED:
3758                       v = _("protected symbol");
3759                       break;
3760                     default:
3761                       v = _("symbol");
3762                       pic = _("; recompile with -fPIC");
3763                       break;
3764                     }
3765
3766                   if (h->def_regular)
3767                     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3768                   else
3769                     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3770
3771                   (*_bfd_error_handler) (fmt, input_bfd,
3772                                          x86_64_elf_howto_table[r_type].name,
3773                                          v,  h->root.root.string, pic);
3774                   bfd_set_error (bfd_error_bad_value);
3775                   return FALSE;
3776                 }
3777             }
3778           /* Fall through.  */
3779
3780         case R_X86_64_8:
3781         case R_X86_64_16:
3782         case R_X86_64_32:
3783         case R_X86_64_PC64:
3784         case R_X86_64_64:
3785           /* FIXME: The ABI says the linker should make sure the value is
3786              the same when it's zeroextended to 64 bit.  */
3787
3788 direct:
3789           if ((input_section->flags & SEC_ALLOC) == 0)
3790             break;
3791
3792           if ((info->shared
3793                && (h == NULL
3794                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3795                    || h->root.type != bfd_link_hash_undefweak)
3796                && ((! IS_X86_64_PCREL_TYPE (r_type)
3797                       && r_type != R_X86_64_SIZE32
3798                       && r_type != R_X86_64_SIZE64)
3799                    || ! SYMBOL_CALLS_LOCAL (info, h)))
3800               || (ELIMINATE_COPY_RELOCS
3801                   && !info->shared
3802                   && h != NULL
3803                   && h->dynindx != -1
3804                   && !h->non_got_ref
3805                   && ((h->def_dynamic
3806                        && !h->def_regular)
3807                       || h->root.type == bfd_link_hash_undefweak
3808                       || h->root.type == bfd_link_hash_undefined)))
3809             {
3810               Elf_Internal_Rela outrel;
3811               bfd_boolean skip, relocate;
3812               asection *sreloc;
3813
3814               /* When generating a shared object, these relocations
3815                  are copied into the output file to be resolved at run
3816                  time.  */
3817               skip = FALSE;
3818               relocate = FALSE;
3819
3820               outrel.r_offset =
3821                 _bfd_elf_section_offset (output_bfd, info, input_section,
3822                                          rel->r_offset);
3823               if (outrel.r_offset == (bfd_vma) -1)
3824                 skip = TRUE;
3825               else if (outrel.r_offset == (bfd_vma) -2)
3826                 skip = TRUE, relocate = TRUE;
3827
3828               outrel.r_offset += (input_section->output_section->vma
3829                                   + input_section->output_offset);
3830
3831               if (skip)
3832                 memset (&outrel, 0, sizeof outrel);
3833
3834               /* h->dynindx may be -1 if this symbol was marked to
3835                  become local.  */
3836               else if (h != NULL
3837                        && h->dynindx != -1
3838                        && (IS_X86_64_PCREL_TYPE (r_type)
3839                            || ! info->shared
3840                            || ! SYMBOLIC_BIND (info, h)
3841                            || ! h->def_regular))
3842                 {
3843                   outrel.r_info = htab->r_info (h->dynindx, r_type);
3844                   outrel.r_addend = rel->r_addend;
3845                 }
3846               else
3847                 {
3848                   /* This symbol is local, or marked to become local.  */
3849                   if (r_type == htab->pointer_r_type)
3850                     {
3851                       relocate = TRUE;
3852                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3853                       outrel.r_addend = relocation + rel->r_addend;
3854                     }
3855                   else if (r_type == R_X86_64_64
3856                            && !ABI_64_P (output_bfd))
3857                     {
3858                       relocate = TRUE;
3859                       outrel.r_info = htab->r_info (0,
3860                                                     R_X86_64_RELATIVE64);
3861                       outrel.r_addend = relocation + rel->r_addend;
3862                       /* Check addend overflow.  */
3863                       if ((outrel.r_addend & 0x80000000)
3864                           != (rel->r_addend & 0x80000000))
3865                         {
3866                           const char *name;
3867                           int addend = rel->r_addend;
3868                           if (h && h->root.root.string)
3869                             name = h->root.root.string;
3870                           else
3871                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3872                                                      sym, NULL);
3873                           if (addend < 0)
3874                             (*_bfd_error_handler)
3875                               (_("%B: addend -0x%x in relocation %s against "
3876                                  "symbol `%s' at 0x%lx in section `%A' is "
3877                                  "out of range"),
3878                                input_bfd, input_section, addend,
3879                                x86_64_elf_howto_table[r_type].name,
3880                                name, (unsigned long) rel->r_offset);
3881                           else
3882                             (*_bfd_error_handler)
3883                               (_("%B: addend 0x%x in relocation %s against "
3884                                  "symbol `%s' at 0x%lx in section `%A' is "
3885                                  "out of range"),
3886                                input_bfd, input_section, addend,
3887                                x86_64_elf_howto_table[r_type].name,
3888                                name, (unsigned long) rel->r_offset);
3889                           bfd_set_error (bfd_error_bad_value);
3890                           return FALSE;
3891                         }
3892                     }
3893                   else
3894                     {
3895                       long sindx;
3896
3897                       if (bfd_is_abs_section (sec))
3898                         sindx = 0;
3899                       else if (sec == NULL || sec->owner == NULL)
3900                         {
3901                           bfd_set_error (bfd_error_bad_value);
3902                           return FALSE;
3903                         }
3904                       else
3905                         {
3906                           asection *osec;
3907
3908                           /* We are turning this relocation into one
3909                              against a section symbol.  It would be
3910                              proper to subtract the symbol's value,
3911                              osec->vma, from the emitted reloc addend,
3912                              but ld.so expects buggy relocs.  */
3913                           osec = sec->output_section;
3914                           sindx = elf_section_data (osec)->dynindx;
3915                           if (sindx == 0)
3916                             {
3917                               asection *oi = htab->elf.text_index_section;
3918                               sindx = elf_section_data (oi)->dynindx;
3919                             }
3920                           BFD_ASSERT (sindx != 0);
3921                         }
3922
3923                       outrel.r_info = htab->r_info (sindx, r_type);
3924                       outrel.r_addend = relocation + rel->r_addend;
3925                     }
3926                 }
3927
3928               sreloc = elf_section_data (input_section)->sreloc;
3929
3930               if (sreloc == NULL || sreloc->contents == NULL)
3931                 {
3932                   r = bfd_reloc_notsupported;
3933                   goto check_relocation_error;
3934                 }
3935
3936               elf_append_rela (output_bfd, sreloc, &outrel);
3937
3938               /* If this reloc is against an external symbol, we do
3939                  not want to fiddle with the addend.  Otherwise, we
3940                  need to include the symbol value so that it becomes
3941                  an addend for the dynamic reloc.  */
3942               if (! relocate)
3943                 continue;
3944             }
3945
3946           break;
3947
3948         case R_X86_64_TLSGD:
3949         case R_X86_64_GOTPC32_TLSDESC:
3950         case R_X86_64_TLSDESC_CALL:
3951         case R_X86_64_GOTTPOFF:
3952           tls_type = GOT_UNKNOWN;
3953           if (h == NULL && local_got_offsets)
3954             tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3955           else if (h != NULL)
3956             tls_type = elf_x86_64_hash_entry (h)->tls_type;
3957
3958           if (! elf_x86_64_tls_transition (info, input_bfd,
3959                                            input_section, contents,
3960                                            symtab_hdr, sym_hashes,
3961                                            &r_type, tls_type, rel,
3962                                            relend, h, r_symndx))
3963             return FALSE;
3964
3965           if (r_type == R_X86_64_TPOFF32)
3966             {
3967               bfd_vma roff = rel->r_offset;
3968
3969               BFD_ASSERT (! unresolved_reloc);
3970
3971               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3972                 {
3973                   /* GD->LE transition.  For 64bit, change
3974                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3975                      .word 0x6666; rex64; call __tls_get_addr
3976                      into:
3977                      movq %fs:0, %rax
3978                      leaq foo@tpoff(%rax), %rax
3979                      For 32bit, change
3980                      leaq foo@tlsgd(%rip), %rdi
3981                      .word 0x6666; rex64; call __tls_get_addr
3982                      into:
3983                      movl %fs:0, %eax
3984                      leaq foo@tpoff(%rax), %rax */
3985                   if (ABI_64_P (output_bfd))
3986                     memcpy (contents + roff - 4,
3987                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3988                             16);
3989                   else
3990                     memcpy (contents + roff - 3,
3991                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3992                             15);
3993                   bfd_put_32 (output_bfd,
3994                               elf_x86_64_tpoff (info, relocation),
3995                               contents + roff + 8);
3996                   /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3997                   rel++;
3998                   continue;
3999                 }
4000               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4001                 {
4002                   /* GDesc -> LE transition.
4003                      It's originally something like:
4004                      leaq x@tlsdesc(%rip), %rax
4005
4006                      Change it to:
4007                      movl $x@tpoff, %rax.  */
4008
4009                   unsigned int val, type;
4010
4011                   type = bfd_get_8 (input_bfd, contents + roff - 3);
4012                   val = bfd_get_8 (input_bfd, contents + roff - 1);
4013                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4014                              contents + roff - 3);
4015                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4016                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4017                              contents + roff - 1);
4018                   bfd_put_32 (output_bfd,
4019                               elf_x86_64_tpoff (info, relocation),
4020                               contents + roff);
4021                   continue;
4022                 }
4023               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4024                 {
4025                   /* GDesc -> LE transition.
4026                      It's originally:
4027                      call *(%rax)
4028                      Turn it into:
4029                      xchg %ax,%ax.  */
4030                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4031                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4032                   continue;
4033                 }
4034               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4035                 {
4036                   /* IE->LE transition:
4037                      Originally it can be one of:
4038                      movq foo@gottpoff(%rip), %reg
4039                      addq foo@gottpoff(%rip), %reg
4040                      We change it into:
4041                      movq $foo, %reg
4042                      leaq foo(%reg), %reg
4043                      addq $foo, %reg.  */
4044
4045                   unsigned int val, type, reg;
4046
4047                   val = bfd_get_8 (input_bfd, contents + roff - 3);
4048                   type = bfd_get_8 (input_bfd, contents + roff - 2);
4049                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
4050                   reg >>= 3;
4051                   if (type == 0x8b)
4052                     {
4053                       /* movq */
4054                       if (val == 0x4c)
4055                         bfd_put_8 (output_bfd, 0x49,
4056                                    contents + roff - 3);
4057                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4058                         bfd_put_8 (output_bfd, 0x41,
4059                                    contents + roff - 3);
4060                       bfd_put_8 (output_bfd, 0xc7,
4061                                  contents + roff - 2);
4062                       bfd_put_8 (output_bfd, 0xc0 | reg,
4063                                  contents + roff - 1);
4064                     }
4065                   else if (reg == 4)
4066                     {
4067                       /* addq -> addq - addressing with %rsp/%r12 is
4068                          special  */
4069                       if (val == 0x4c)
4070                         bfd_put_8 (output_bfd, 0x49,
4071                                    contents + roff - 3);
4072                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4073                         bfd_put_8 (output_bfd, 0x41,
4074                                    contents + roff - 3);
4075                       bfd_put_8 (output_bfd, 0x81,
4076                                  contents + roff - 2);
4077                       bfd_put_8 (output_bfd, 0xc0 | reg,
4078                                  contents + roff - 1);
4079                     }
4080                   else
4081                     {
4082                       /* addq -> leaq */
4083                       if (val == 0x4c)
4084                         bfd_put_8 (output_bfd, 0x4d,
4085                                    contents + roff - 3);
4086                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4087                         bfd_put_8 (output_bfd, 0x45,
4088                                    contents + roff - 3);
4089                       bfd_put_8 (output_bfd, 0x8d,
4090                                  contents + roff - 2);
4091                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4092                                  contents + roff - 1);
4093                     }
4094                   bfd_put_32 (output_bfd,
4095                               elf_x86_64_tpoff (info, relocation),
4096                               contents + roff);
4097                   continue;
4098                 }
4099               else
4100                 BFD_ASSERT (FALSE);
4101             }
4102
4103           if (htab->elf.sgot == NULL)
4104             abort ();
4105
4106           if (h != NULL)
4107             {
4108               off = h->got.offset;
4109               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4110             }
4111           else
4112             {
4113               if (local_got_offsets == NULL)
4114                 abort ();
4115
4116               off = local_got_offsets[r_symndx];
4117               offplt = local_tlsdesc_gotents[r_symndx];
4118             }
4119
4120           if ((off & 1) != 0)
4121             off &= ~1;
4122           else
4123             {
4124               Elf_Internal_Rela outrel;
4125               int dr_type, indx;
4126               asection *sreloc;
4127
4128               if (htab->elf.srelgot == NULL)
4129                 abort ();
4130
4131               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4132
4133               if (GOT_TLS_GDESC_P (tls_type))
4134                 {
4135                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4136                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4137                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4138                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4139                                      + htab->elf.sgotplt->output_offset
4140                                      + offplt
4141                                      + htab->sgotplt_jump_table_size);
4142                   sreloc = htab->elf.srelplt;
4143                   if (indx == 0)
4144                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4145                   else
4146                     outrel.r_addend = 0;
4147                   elf_append_rela (output_bfd, sreloc, &outrel);
4148                 }
4149
4150               sreloc = htab->elf.srelgot;
4151
4152               outrel.r_offset = (htab->elf.sgot->output_section->vma
4153                                  + htab->elf.sgot->output_offset + off);
4154
4155               if (GOT_TLS_GD_P (tls_type))
4156                 dr_type = R_X86_64_DTPMOD64;
4157               else if (GOT_TLS_GDESC_P (tls_type))
4158                 goto dr_done;
4159               else
4160                 dr_type = R_X86_64_TPOFF64;
4161
4162               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4163               outrel.r_addend = 0;
4164               if ((dr_type == R_X86_64_TPOFF64
4165                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
4166                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4167               outrel.r_info = htab->r_info (indx, dr_type);
4168
4169               elf_append_rela (output_bfd, sreloc, &outrel);
4170
4171               if (GOT_TLS_GD_P (tls_type))
4172                 {
4173                   if (indx == 0)
4174                     {
4175                       BFD_ASSERT (! unresolved_reloc);
4176                       bfd_put_64 (output_bfd,
4177                                   relocation - elf_x86_64_dtpoff_base (info),
4178                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4179                     }
4180                   else
4181                     {
4182                       bfd_put_64 (output_bfd, 0,
4183                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4184                       outrel.r_info = htab->r_info (indx,
4185                                                     R_X86_64_DTPOFF64);
4186                       outrel.r_offset += GOT_ENTRY_SIZE;
4187                       elf_append_rela (output_bfd, sreloc,
4188                                                 &outrel);
4189                     }
4190                 }
4191
4192             dr_done:
4193               if (h != NULL)
4194                 h->got.offset |= 1;
4195               else
4196                 local_got_offsets[r_symndx] |= 1;
4197             }
4198
4199           if (off >= (bfd_vma) -2
4200               && ! GOT_TLS_GDESC_P (tls_type))
4201             abort ();
4202           if (r_type == ELF32_R_TYPE (rel->r_info))
4203             {
4204               if (r_type == R_X86_64_GOTPC32_TLSDESC
4205                   || r_type == R_X86_64_TLSDESC_CALL)
4206                 relocation = htab->elf.sgotplt->output_section->vma
4207                   + htab->elf.sgotplt->output_offset
4208                   + offplt + htab->sgotplt_jump_table_size;
4209               else
4210                 relocation = htab->elf.sgot->output_section->vma
4211                   + htab->elf.sgot->output_offset + off;
4212               unresolved_reloc = FALSE;
4213             }
4214           else
4215             {
4216               bfd_vma roff = rel->r_offset;
4217
4218               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4219                 {
4220                   /* GD->IE transition.  For 64bit, change
4221                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4222                      .word 0x6666; rex64; call __tls_get_addr@plt
4223                      into:
4224                      movq %fs:0, %rax
4225                      addq foo@gottpoff(%rip), %rax
4226                      For 32bit, change
4227                      leaq foo@tlsgd(%rip), %rdi
4228                      .word 0x6666; rex64; call __tls_get_addr@plt
4229                      into:
4230                      movl %fs:0, %eax
4231                      addq foo@gottpoff(%rip), %rax */
4232                   if (ABI_64_P (output_bfd))
4233                     memcpy (contents + roff - 4,
4234                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4235                             16);
4236                   else
4237                     memcpy (contents + roff - 3,
4238                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4239                             15);
4240
4241                   relocation = (htab->elf.sgot->output_section->vma
4242                                 + htab->elf.sgot->output_offset + off
4243                                 - roff
4244                                 - input_section->output_section->vma
4245                                 - input_section->output_offset
4246                                 - 12);
4247                   bfd_put_32 (output_bfd, relocation,
4248                               contents + roff + 8);
4249                   /* Skip R_X86_64_PLT32.  */
4250                   rel++;
4251                   continue;
4252                 }
4253               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4254                 {
4255                   /* GDesc -> IE transition.
4256                      It's originally something like:
4257                      leaq x@tlsdesc(%rip), %rax
4258
4259                      Change it to:
4260                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
4261
4262                   /* Now modify the instruction as appropriate. To
4263                      turn a leaq into a movq in the form we use it, it
4264                      suffices to change the second byte from 0x8d to
4265                      0x8b.  */
4266                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4267
4268                   bfd_put_32 (output_bfd,
4269                               htab->elf.sgot->output_section->vma
4270                               + htab->elf.sgot->output_offset + off
4271                               - rel->r_offset
4272                               - input_section->output_section->vma
4273                               - input_section->output_offset
4274                               - 4,
4275                               contents + roff);
4276                   continue;
4277                 }
4278               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4279                 {
4280                   /* GDesc -> IE transition.
4281                      It's originally:
4282                      call *(%rax)
4283
4284                      Change it to:
4285                      xchg %ax, %ax.  */
4286
4287                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4288                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4289                   continue;
4290                 }
4291               else
4292                 BFD_ASSERT (FALSE);
4293             }
4294           break;
4295
4296         case R_X86_64_TLSLD:
4297           if (! elf_x86_64_tls_transition (info, input_bfd,
4298                                            input_section, contents,
4299                                            symtab_hdr, sym_hashes,
4300                                            &r_type, GOT_UNKNOWN,
4301                                            rel, relend, h, r_symndx))
4302             return FALSE;
4303
4304           if (r_type != R_X86_64_TLSLD)
4305             {
4306               /* LD->LE transition:
4307                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4308                  For 64bit, we change it into:
4309                  .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4310                  For 32bit, we change it into:
4311                  nopl 0x0(%rax); movl %fs:0, %eax.  */
4312
4313               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4314               if (ABI_64_P (output_bfd))
4315                 memcpy (contents + rel->r_offset - 3,
4316                         "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4317               else
4318                 memcpy (contents + rel->r_offset - 3,
4319                         "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4320               /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
4321               rel++;
4322               continue;
4323             }
4324
4325           if (htab->elf.sgot == NULL)
4326             abort ();
4327
4328           off = htab->tls_ld_got.offset;
4329           if (off & 1)
4330             off &= ~1;
4331           else
4332             {
4333               Elf_Internal_Rela outrel;
4334
4335               if (htab->elf.srelgot == NULL)
4336                 abort ();
4337
4338               outrel.r_offset = (htab->elf.sgot->output_section->vma
4339                                  + htab->elf.sgot->output_offset + off);
4340
4341               bfd_put_64 (output_bfd, 0,
4342                           htab->elf.sgot->contents + off);
4343               bfd_put_64 (output_bfd, 0,
4344                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4345               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4346               outrel.r_addend = 0;
4347               elf_append_rela (output_bfd, htab->elf.srelgot,
4348                                         &outrel);
4349               htab->tls_ld_got.offset |= 1;
4350             }
4351           relocation = htab->elf.sgot->output_section->vma
4352                        + htab->elf.sgot->output_offset + off;
4353           unresolved_reloc = FALSE;
4354           break;
4355
4356         case R_X86_64_DTPOFF32:
4357           if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4358             relocation -= elf_x86_64_dtpoff_base (info);
4359           else
4360             relocation = elf_x86_64_tpoff (info, relocation);
4361           break;
4362
4363         case R_X86_64_TPOFF32:
4364         case R_X86_64_TPOFF64:
4365           BFD_ASSERT (info->executable);
4366           relocation = elf_x86_64_tpoff (info, relocation);
4367           break;
4368
4369         default:
4370           break;
4371         }
4372
4373       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4374          because such sections are not SEC_ALLOC and thus ld.so will
4375          not process them.  */
4376       if (unresolved_reloc
4377           && !((input_section->flags & SEC_DEBUGGING) != 0
4378                && h->def_dynamic)
4379           && _bfd_elf_section_offset (output_bfd, info, input_section,
4380                                       rel->r_offset) != (bfd_vma) -1)
4381         {
4382           (*_bfd_error_handler)
4383             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4384              input_bfd,
4385              input_section,
4386              (long) rel->r_offset,
4387              howto->name,
4388              h->root.root.string);
4389           return FALSE;
4390         }
4391
4392 do_relocation:
4393       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4394                                     contents, rel->r_offset,
4395                                     relocation, rel->r_addend);
4396
4397 check_relocation_error:
4398       if (r != bfd_reloc_ok)
4399         {
4400           const char *name;
4401
4402           if (h != NULL)
4403             name = h->root.root.string;
4404           else
4405             {
4406               name = bfd_elf_string_from_elf_section (input_bfd,
4407                                                       symtab_hdr->sh_link,
4408                                                       sym->st_name);
4409               if (name == NULL)
4410                 return FALSE;
4411               if (*name == '\0')
4412                 name = bfd_section_name (input_bfd, sec);
4413             }
4414
4415           if (r == bfd_reloc_overflow)
4416             {
4417               if (! ((*info->callbacks->reloc_overflow)
4418                      (info, (h ? &h->root : NULL), name, howto->name,
4419                       (bfd_vma) 0, input_bfd, input_section,
4420                       rel->r_offset)))
4421                 return FALSE;
4422             }
4423           else
4424             {
4425               (*_bfd_error_handler)
4426                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4427                  input_bfd, input_section,
4428                  (long) rel->r_offset, name, (int) r);
4429               return FALSE;
4430             }
4431         }
4432     }
4433
4434   return TRUE;
4435 }
4436
4437 /* Finish up dynamic symbol handling.  We set the contents of various
4438    dynamic sections here.  */
4439
4440 static bfd_boolean
4441 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4442                                   struct bfd_link_info *info,
4443                                   struct elf_link_hash_entry *h,
4444                                   Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4445 {
4446   struct elf_x86_64_link_hash_table *htab;
4447   const struct elf_x86_64_backend_data *const abed
4448     = get_elf_x86_64_backend_data (output_bfd);
4449
4450   htab = elf_x86_64_hash_table (info);
4451   if (htab == NULL)
4452     return FALSE;
4453
4454   if (h->plt.offset != (bfd_vma) -1)
4455     {
4456       bfd_vma plt_index;
4457       bfd_vma got_offset;
4458       Elf_Internal_Rela rela;
4459       bfd_byte *loc;
4460       asection *plt, *gotplt, *relplt;
4461       const struct elf_backend_data *bed;
4462
4463       /* When building a static executable, use .iplt, .igot.plt and
4464          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4465       if (htab->elf.splt != NULL)
4466         {
4467           plt = htab->elf.splt;
4468           gotplt = htab->elf.sgotplt;
4469           relplt = htab->elf.srelplt;
4470         }
4471       else
4472         {
4473           plt = htab->elf.iplt;
4474           gotplt = htab->elf.igotplt;
4475           relplt = htab->elf.irelplt;
4476         }
4477
4478       /* This symbol has an entry in the procedure linkage table.  Set
4479          it up.  */
4480       if ((h->dynindx == -1
4481            && !((h->forced_local || info->executable)
4482                 && h->def_regular
4483                 && h->type == STT_GNU_IFUNC))
4484           || plt == NULL
4485           || gotplt == NULL
4486           || relplt == NULL)
4487         abort ();
4488
4489       /* Get the index in the procedure linkage table which
4490          corresponds to this symbol.  This is the index of this symbol
4491          in all the symbols for which we are making plt entries.  The
4492          first entry in the procedure linkage table is reserved.
4493
4494          Get the offset into the .got table of the entry that
4495          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
4496          bytes. The first three are reserved for the dynamic linker.
4497
4498          For static executables, we don't reserve anything.  */
4499
4500       if (plt == htab->elf.splt)
4501         {
4502           got_offset = h->plt.offset / abed->plt_entry_size - 1;
4503           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4504         }
4505       else
4506         {
4507           got_offset = h->plt.offset / abed->plt_entry_size;
4508           got_offset = got_offset * GOT_ENTRY_SIZE;
4509         }
4510
4511       /* Fill in the entry in the procedure linkage table.  */
4512       memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4513               abed->plt_entry_size);
4514
4515       /* Insert the relocation positions of the plt section.  */
4516
4517       /* Put offset the PC-relative instruction referring to the GOT entry,
4518          subtracting the size of that instruction.  */
4519       bfd_put_32 (output_bfd,
4520                   (gotplt->output_section->vma
4521                    + gotplt->output_offset
4522                    + got_offset
4523                    - plt->output_section->vma
4524                    - plt->output_offset
4525                    - h->plt.offset
4526                    - abed->plt_got_insn_size),
4527                   plt->contents + h->plt.offset + abed->plt_got_offset);
4528
4529       /* Fill in the entry in the global offset table, initially this
4530          points to the second part of the PLT entry.  */
4531       bfd_put_64 (output_bfd, (plt->output_section->vma
4532                                + plt->output_offset
4533                                + h->plt.offset + abed->plt_lazy_offset),
4534                   gotplt->contents + got_offset);
4535
4536       /* Fill in the entry in the .rela.plt section.  */
4537       rela.r_offset = (gotplt->output_section->vma
4538                        + gotplt->output_offset
4539                        + got_offset);
4540       if (h->dynindx == -1
4541           || ((info->executable
4542                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4543               && h->def_regular
4544               && h->type == STT_GNU_IFUNC))
4545         {
4546           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4547              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
4548           rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4549           rela.r_addend = (h->root.u.def.value
4550                            + h->root.u.def.section->output_section->vma
4551                            + h->root.u.def.section->output_offset);
4552           /* R_X86_64_IRELATIVE comes last.  */
4553           plt_index = htab->next_irelative_index--;
4554         }
4555       else
4556         {
4557           rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4558           rela.r_addend = 0;
4559           plt_index = htab->next_jump_slot_index++;
4560         }
4561
4562       /* Don't fill PLT entry for static executables.  */
4563       if (plt == htab->elf.splt)
4564         {
4565           /* Put relocation index.  */
4566           bfd_put_32 (output_bfd, plt_index,
4567                       plt->contents + h->plt.offset + abed->plt_reloc_offset);
4568           /* Put offset for jmp .PLT0.  */
4569           bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4570                       plt->contents + h->plt.offset + abed->plt_plt_offset);
4571         }
4572
4573       bed = get_elf_backend_data (output_bfd);
4574       loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4575       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4576
4577       if (!h->def_regular)
4578         {
4579           /* Mark the symbol as undefined, rather than as defined in
4580              the .plt section.  Leave the value if there were any
4581              relocations where pointer equality matters (this is a clue
4582              for the dynamic linker, to make function pointer
4583              comparisons work between an application and shared
4584              library), otherwise set it to zero.  If a function is only
4585              called from a binary, there is no need to slow down
4586              shared libraries because of that.  */
4587           sym->st_shndx = SHN_UNDEF;
4588           if (!h->pointer_equality_needed)
4589             sym->st_value = 0;
4590         }
4591     }
4592
4593   if (h->got.offset != (bfd_vma) -1
4594       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4595       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4596     {
4597       Elf_Internal_Rela rela;
4598
4599       /* This symbol has an entry in the global offset table.  Set it
4600          up.  */
4601       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4602         abort ();
4603
4604       rela.r_offset = (htab->elf.sgot->output_section->vma
4605                        + htab->elf.sgot->output_offset
4606                        + (h->got.offset &~ (bfd_vma) 1));
4607
4608       /* If this is a static link, or it is a -Bsymbolic link and the
4609          symbol is defined locally or was forced to be local because
4610          of a version file, we just want to emit a RELATIVE reloc.
4611          The entry in the global offset table will already have been
4612          initialized in the relocate_section function.  */
4613       if (h->def_regular
4614           && h->type == STT_GNU_IFUNC)
4615         {
4616           if (info->shared)
4617             {
4618               /* Generate R_X86_64_GLOB_DAT.  */
4619               goto do_glob_dat;
4620             }
4621           else
4622             {
4623               asection *plt;
4624
4625               if (!h->pointer_equality_needed)
4626                 abort ();
4627
4628               /* For non-shared object, we can't use .got.plt, which
4629                  contains the real function addres if we need pointer
4630                  equality.  We load the GOT entry with the PLT entry.  */
4631               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4632               bfd_put_64 (output_bfd, (plt->output_section->vma
4633                                        + plt->output_offset
4634                                        + h->plt.offset),
4635                           htab->elf.sgot->contents + h->got.offset);
4636               return TRUE;
4637             }
4638         }
4639       else if (info->shared
4640                && SYMBOL_REFERENCES_LOCAL (info, h))
4641         {
4642           if (!h->def_regular)
4643             return FALSE;
4644           BFD_ASSERT((h->got.offset & 1) != 0);
4645           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4646           rela.r_addend = (h->root.u.def.value
4647                            + h->root.u.def.section->output_section->vma
4648                            + h->root.u.def.section->output_offset);
4649         }
4650       else
4651         {
4652           BFD_ASSERT((h->got.offset & 1) == 0);
4653 do_glob_dat:
4654           bfd_put_64 (output_bfd, (bfd_vma) 0,
4655                       htab->elf.sgot->contents + h->got.offset);
4656           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4657           rela.r_addend = 0;
4658         }
4659
4660       elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4661     }
4662
4663   if (h->needs_copy)
4664     {
4665       Elf_Internal_Rela rela;
4666
4667       /* This symbol needs a copy reloc.  Set it up.  */
4668
4669       if (h->dynindx == -1
4670           || (h->root.type != bfd_link_hash_defined
4671               && h->root.type != bfd_link_hash_defweak)
4672           || htab->srelbss == NULL)
4673         abort ();
4674
4675       rela.r_offset = (h->root.u.def.value
4676                        + h->root.u.def.section->output_section->vma
4677                        + h->root.u.def.section->output_offset);
4678       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4679       rela.r_addend = 0;
4680       elf_append_rela (output_bfd, htab->srelbss, &rela);
4681     }
4682
4683   return TRUE;
4684 }
4685
4686 /* Finish up local dynamic symbol handling.  We set the contents of
4687    various dynamic sections here.  */
4688
4689 static bfd_boolean
4690 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4691 {
4692   struct elf_link_hash_entry *h
4693     = (struct elf_link_hash_entry *) *slot;
4694   struct bfd_link_info *info
4695     = (struct bfd_link_info *) inf;
4696
4697   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4698                                              info, h, NULL);
4699 }
4700
4701 /* Used to decide how to sort relocs in an optimal manner for the
4702    dynamic linker, before writing them out.  */
4703
4704 static enum elf_reloc_type_class
4705 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4706 {
4707   switch ((int) ELF32_R_TYPE (rela->r_info))
4708     {
4709     case R_X86_64_RELATIVE:
4710     case R_X86_64_RELATIVE64:
4711       return reloc_class_relative;
4712     case R_X86_64_JUMP_SLOT:
4713       return reloc_class_plt;
4714     case R_X86_64_COPY:
4715       return reloc_class_copy;
4716     default:
4717       return reloc_class_normal;
4718     }
4719 }
4720
4721 /* Finish up the dynamic sections.  */
4722
4723 static bfd_boolean
4724 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4725                                     struct bfd_link_info *info)
4726 {
4727   struct elf_x86_64_link_hash_table *htab;
4728   bfd *dynobj;
4729   asection *sdyn;
4730   const struct elf_x86_64_backend_data *const abed
4731     = get_elf_x86_64_backend_data (output_bfd);
4732
4733   htab = elf_x86_64_hash_table (info);
4734   if (htab == NULL)
4735     return FALSE;
4736
4737   dynobj = htab->elf.dynobj;
4738   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4739
4740   if (htab->elf.dynamic_sections_created)
4741     {
4742       bfd_byte *dyncon, *dynconend;
4743       const struct elf_backend_data *bed;
4744       bfd_size_type sizeof_dyn;
4745
4746       if (sdyn == NULL || htab->elf.sgot == NULL)
4747         abort ();
4748
4749       bed = get_elf_backend_data (dynobj);
4750       sizeof_dyn = bed->s->sizeof_dyn;
4751       dyncon = sdyn->contents;
4752       dynconend = sdyn->contents + sdyn->size;
4753       for (; dyncon < dynconend; dyncon += sizeof_dyn)
4754         {
4755           Elf_Internal_Dyn dyn;
4756           asection *s;
4757
4758           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4759
4760           switch (dyn.d_tag)
4761             {
4762             default:
4763               continue;
4764
4765             case DT_PLTGOT:
4766               s = htab->elf.sgotplt;
4767               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4768               break;
4769
4770             case DT_JMPREL:
4771               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4772               break;
4773
4774             case DT_PLTRELSZ:
4775               s = htab->elf.srelplt->output_section;
4776               dyn.d_un.d_val = s->size;
4777               break;
4778
4779             case DT_RELASZ:
4780               /* The procedure linkage table relocs (DT_JMPREL) should
4781                  not be included in the overall relocs (DT_RELA).
4782                  Therefore, we override the DT_RELASZ entry here to
4783                  make it not include the JMPREL relocs.  Since the
4784                  linker script arranges for .rela.plt to follow all
4785                  other relocation sections, we don't have to worry
4786                  about changing the DT_RELA entry.  */
4787               if (htab->elf.srelplt != NULL)
4788                 {
4789                   s = htab->elf.srelplt->output_section;
4790                   dyn.d_un.d_val -= s->size;
4791                 }
4792               break;
4793
4794             case DT_TLSDESC_PLT:
4795               s = htab->elf.splt;
4796               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4797                 + htab->tlsdesc_plt;
4798               break;
4799
4800             case DT_TLSDESC_GOT:
4801               s = htab->elf.sgot;
4802               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4803                 + htab->tlsdesc_got;
4804               break;
4805             }
4806
4807           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4808         }
4809
4810       /* Fill in the special first entry in the procedure linkage table.  */
4811       if (htab->elf.splt && htab->elf.splt->size > 0)
4812         {
4813           /* Fill in the first entry in the procedure linkage table.  */
4814           memcpy (htab->elf.splt->contents,
4815                   abed->plt0_entry, abed->plt_entry_size);
4816           /* Add offset for pushq GOT+8(%rip), since the instruction
4817              uses 6 bytes subtract this value.  */
4818           bfd_put_32 (output_bfd,
4819                       (htab->elf.sgotplt->output_section->vma
4820                        + htab->elf.sgotplt->output_offset
4821                        + 8
4822                        - htab->elf.splt->output_section->vma
4823                        - htab->elf.splt->output_offset
4824                        - 6),
4825                       htab->elf.splt->contents + abed->plt0_got1_offset);
4826           /* Add offset for the PC-relative instruction accessing GOT+16,
4827              subtracting the offset to the end of that instruction.  */
4828           bfd_put_32 (output_bfd,
4829                       (htab->elf.sgotplt->output_section->vma
4830                        + htab->elf.sgotplt->output_offset
4831                        + 16
4832                        - htab->elf.splt->output_section->vma
4833                        - htab->elf.splt->output_offset
4834                        - abed->plt0_got2_insn_end),
4835                       htab->elf.splt->contents + abed->plt0_got2_offset);
4836
4837           elf_section_data (htab->elf.splt->output_section)
4838             ->this_hdr.sh_entsize = abed->plt_entry_size;
4839
4840           if (htab->tlsdesc_plt)
4841             {
4842               bfd_put_64 (output_bfd, (bfd_vma) 0,
4843                           htab->elf.sgot->contents + htab->tlsdesc_got);
4844
4845               memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4846                       abed->plt0_entry, abed->plt_entry_size);
4847
4848               /* Add offset for pushq GOT+8(%rip), since the
4849                  instruction uses 6 bytes subtract this value.  */
4850               bfd_put_32 (output_bfd,
4851                           (htab->elf.sgotplt->output_section->vma
4852                            + htab->elf.sgotplt->output_offset
4853                            + 8
4854                            - htab->elf.splt->output_section->vma
4855                            - htab->elf.splt->output_offset
4856                            - htab->tlsdesc_plt
4857                            - 6),
4858                           htab->elf.splt->contents
4859                           + htab->tlsdesc_plt + abed->plt0_got1_offset);
4860           /* Add offset for the PC-relative instruction accessing GOT+TDG,
4861              where TGD stands for htab->tlsdesc_got, subtracting the offset
4862              to the end of that instruction.  */
4863               bfd_put_32 (output_bfd,
4864                           (htab->elf.sgot->output_section->vma
4865                            + htab->elf.sgot->output_offset
4866                            + htab->tlsdesc_got
4867                            - htab->elf.splt->output_section->vma
4868                            - htab->elf.splt->output_offset
4869                            - htab->tlsdesc_plt
4870                            - abed->plt0_got2_insn_end),
4871                           htab->elf.splt->contents
4872                           + htab->tlsdesc_plt + abed->plt0_got2_offset);
4873             }
4874         }
4875     }
4876
4877   if (htab->elf.sgotplt)
4878     {
4879       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4880         {
4881           (*_bfd_error_handler)
4882             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4883           return FALSE;
4884         }
4885
4886       /* Fill in the first three entries in the global offset table.  */
4887       if (htab->elf.sgotplt->size > 0)
4888         {
4889           /* Set the first entry in the global offset table to the address of
4890              the dynamic section.  */
4891           if (sdyn == NULL)
4892             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4893           else
4894             bfd_put_64 (output_bfd,
4895                         sdyn->output_section->vma + sdyn->output_offset,
4896                         htab->elf.sgotplt->contents);
4897           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
4898           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4899           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4900         }
4901
4902       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4903         GOT_ENTRY_SIZE;
4904     }
4905
4906   /* Adjust .eh_frame for .plt section.  */
4907   if (htab->plt_eh_frame != NULL
4908       && htab->plt_eh_frame->contents != NULL)
4909     {
4910       if (htab->elf.splt != NULL
4911           && htab->elf.splt->size != 0
4912           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4913           && htab->elf.splt->output_section != NULL
4914           && htab->plt_eh_frame->output_section != NULL)
4915         {
4916           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4917           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4918                                    + htab->plt_eh_frame->output_offset
4919                                    + PLT_FDE_START_OFFSET;
4920           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4921                              htab->plt_eh_frame->contents
4922                              + PLT_FDE_START_OFFSET);
4923         }
4924       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4925         {
4926           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4927                                                  htab->plt_eh_frame,
4928                                                  htab->plt_eh_frame->contents))
4929             return FALSE;
4930         }
4931     }
4932
4933   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4934     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4935       = GOT_ENTRY_SIZE;
4936
4937   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4938   htab_traverse (htab->loc_hash_table,
4939                  elf_x86_64_finish_local_dynamic_symbol,
4940                  info);
4941
4942   return TRUE;
4943 }
4944
4945 /* Return address for Ith PLT stub in section PLT, for relocation REL
4946    or (bfd_vma) -1 if it should not be included.  */
4947
4948 static bfd_vma
4949 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4950                         const arelent *rel ATTRIBUTE_UNUSED)
4951 {
4952   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4953 }
4954
4955 /* Handle an x86-64 specific section when reading an object file.  This
4956    is called when elfcode.h finds a section with an unknown type.  */
4957
4958 static bfd_boolean
4959 elf_x86_64_section_from_shdr (bfd *abfd,
4960                                 Elf_Internal_Shdr *hdr,
4961                                 const char *name,
4962                                 int shindex)
4963 {
4964   if (hdr->sh_type != SHT_X86_64_UNWIND)
4965     return FALSE;
4966
4967   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4968     return FALSE;
4969
4970   return TRUE;
4971 }
4972
4973 /* Hook called by the linker routine which adds symbols from an object
4974    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4975    of .bss.  */
4976
4977 static bfd_boolean
4978 elf_x86_64_add_symbol_hook (bfd *abfd,
4979                             struct bfd_link_info *info,
4980                             Elf_Internal_Sym *sym,
4981                             const char **namep ATTRIBUTE_UNUSED,
4982                             flagword *flagsp ATTRIBUTE_UNUSED,
4983                             asection **secp,
4984                             bfd_vma *valp)
4985 {
4986   asection *lcomm;
4987
4988   switch (sym->st_shndx)
4989     {
4990     case SHN_X86_64_LCOMMON:
4991       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4992       if (lcomm == NULL)
4993         {
4994           lcomm = bfd_make_section_with_flags (abfd,
4995                                                "LARGE_COMMON",
4996                                                (SEC_ALLOC
4997                                                 | SEC_IS_COMMON
4998                                                 | SEC_LINKER_CREATED));
4999           if (lcomm == NULL)
5000             return FALSE;
5001           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
5002         }
5003       *secp = lcomm;
5004       *valp = sym->st_size;
5005       return TRUE;
5006     }
5007
5008   if ((abfd->flags & DYNAMIC) == 0
5009       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5010           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5011     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5012
5013   return TRUE;
5014 }
5015
5016
5017 /* Given a BFD section, try to locate the corresponding ELF section
5018    index.  */
5019
5020 static bfd_boolean
5021 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5022                                          asection *sec, int *index_return)
5023 {
5024   if (sec == &_bfd_elf_large_com_section)
5025     {
5026       *index_return = SHN_X86_64_LCOMMON;
5027       return TRUE;
5028     }
5029   return FALSE;
5030 }
5031
5032 /* Process a symbol.  */
5033
5034 static void
5035 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5036                               asymbol *asym)
5037 {
5038   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5039
5040   switch (elfsym->internal_elf_sym.st_shndx)
5041     {
5042     case SHN_X86_64_LCOMMON:
5043       asym->section = &_bfd_elf_large_com_section;
5044       asym->value = elfsym->internal_elf_sym.st_size;
5045       /* Common symbol doesn't set BSF_GLOBAL.  */
5046       asym->flags &= ~BSF_GLOBAL;
5047       break;
5048     }
5049 }
5050
5051 static bfd_boolean
5052 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5053 {
5054   return (sym->st_shndx == SHN_COMMON
5055           || sym->st_shndx == SHN_X86_64_LCOMMON);
5056 }
5057
5058 static unsigned int
5059 elf_x86_64_common_section_index (asection *sec)
5060 {
5061   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5062     return SHN_COMMON;
5063   else
5064     return SHN_X86_64_LCOMMON;
5065 }
5066
5067 static asection *
5068 elf_x86_64_common_section (asection *sec)
5069 {
5070   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5071     return bfd_com_section_ptr;
5072   else
5073     return &_bfd_elf_large_com_section;
5074 }
5075
5076 static bfd_boolean
5077 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5078                          struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
5079                          struct elf_link_hash_entry *h,
5080                          Elf_Internal_Sym *sym,
5081                          asection **psec,
5082                          bfd_vma *pvalue ATTRIBUTE_UNUSED,
5083                          unsigned int *pold_alignment ATTRIBUTE_UNUSED,
5084                          bfd_boolean *skip ATTRIBUTE_UNUSED,
5085                          bfd_boolean *override ATTRIBUTE_UNUSED,
5086                          bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
5087                          bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
5088                          bfd_boolean *newdyn ATTRIBUTE_UNUSED,
5089                          bfd_boolean *newdef,
5090                          bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
5091                          bfd_boolean *newweak ATTRIBUTE_UNUSED,
5092                          bfd *abfd ATTRIBUTE_UNUSED,
5093                          asection **sec,
5094                          bfd_boolean *olddyn ATTRIBUTE_UNUSED,
5095                          bfd_boolean *olddef,
5096                          bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
5097                          bfd_boolean *oldweak ATTRIBUTE_UNUSED,
5098                          bfd *oldbfd,
5099                          asection **oldsec)
5100 {
5101   /* A normal common symbol and a large common symbol result in a
5102      normal common symbol.  We turn the large common symbol into a
5103      normal one.  */
5104   if (!*olddef
5105       && h->root.type == bfd_link_hash_common
5106       && !*newdef
5107       && bfd_is_com_section (*sec)
5108       && *oldsec != *sec)
5109     {
5110       if (sym->st_shndx == SHN_COMMON
5111           && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
5112         {
5113           h->root.u.c.p->section
5114             = bfd_make_section_old_way (oldbfd, "COMMON");
5115           h->root.u.c.p->section->flags = SEC_ALLOC;
5116         }
5117       else if (sym->st_shndx == SHN_X86_64_LCOMMON
5118                && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
5119         *psec = *sec = bfd_com_section_ptr;
5120     }
5121
5122   return TRUE;
5123 }
5124
5125 static int
5126 elf_x86_64_additional_program_headers (bfd *abfd,
5127                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
5128 {
5129   asection *s;
5130   int count = 0;
5131
5132   /* Check to see if we need a large readonly segment.  */
5133   s = bfd_get_section_by_name (abfd, ".lrodata");
5134   if (s && (s->flags & SEC_LOAD))
5135     count++;
5136
5137   /* Check to see if we need a large data segment.  Since .lbss sections
5138      is placed right after the .bss section, there should be no need for
5139      a large data segment just because of .lbss.  */
5140   s = bfd_get_section_by_name (abfd, ".ldata");
5141   if (s && (s->flags & SEC_LOAD))
5142     count++;
5143
5144   return count;
5145 }
5146
5147 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5148
5149 static bfd_boolean
5150 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5151 {
5152   if (h->plt.offset != (bfd_vma) -1
5153       && !h->def_regular
5154       && !h->pointer_equality_needed)
5155     return FALSE;
5156
5157   return _bfd_elf_hash_symbol (h);
5158 }
5159
5160 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5161
5162 static bfd_boolean
5163 elf_x86_64_relocs_compatible (const bfd_target *input,
5164                               const bfd_target *output)
5165 {
5166   return ((xvec_get_elf_backend_data (input)->s->elfclass
5167            == xvec_get_elf_backend_data (output)->s->elfclass)
5168           && _bfd_elf_relocs_compatible (input, output));
5169 }
5170
5171 static const struct bfd_elf_special_section
5172   elf_x86_64_special_sections[]=
5173 {
5174   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5175   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5176   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5177   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5178   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5179   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5180   { NULL,                       0,          0, 0,            0 }
5181 };
5182
5183 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
5184 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
5185 #define ELF_ARCH                            bfd_arch_i386
5186 #define ELF_TARGET_ID                       X86_64_ELF_DATA
5187 #define ELF_MACHINE_CODE                    EM_X86_64
5188 #define ELF_MAXPAGESIZE                     0x200000
5189 #define ELF_MINPAGESIZE                     0x1000
5190 #define ELF_COMMONPAGESIZE                  0x1000
5191
5192 #define elf_backend_can_gc_sections         1
5193 #define elf_backend_can_refcount            1
5194 #define elf_backend_want_got_plt            1
5195 #define elf_backend_plt_readonly            1
5196 #define elf_backend_want_plt_sym            0
5197 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
5198 #define elf_backend_rela_normal             1
5199 #define elf_backend_plt_alignment           4
5200
5201 #define elf_info_to_howto                   elf_x86_64_info_to_howto
5202
5203 #define bfd_elf64_bfd_link_hash_table_create \
5204   elf_x86_64_link_hash_table_create
5205 #define bfd_elf64_bfd_link_hash_table_free \
5206   elf_x86_64_link_hash_table_free
5207 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
5208 #define bfd_elf64_bfd_reloc_name_lookup \
5209   elf_x86_64_reloc_name_lookup
5210
5211 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
5212 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
5213 #define elf_backend_check_relocs            elf_x86_64_check_relocs
5214 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
5215 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5216 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5217 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
5218 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
5219 #define elf_backend_gc_sweep_hook           elf_x86_64_gc_sweep_hook
5220 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
5221 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
5222 #ifdef CORE_HEADER
5223 #define elf_backend_write_core_note         elf_x86_64_write_core_note
5224 #endif
5225 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
5226 #define elf_backend_relocate_section        elf_x86_64_relocate_section
5227 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
5228 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
5229 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
5230 #define elf_backend_plt_sym_val             elf_x86_64_plt_sym_val
5231 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5232 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
5233
5234 #define elf_backend_section_from_shdr \
5235         elf_x86_64_section_from_shdr
5236
5237 #define elf_backend_section_from_bfd_section \
5238   elf_x86_64_elf_section_from_bfd_section
5239 #define elf_backend_add_symbol_hook \
5240   elf_x86_64_add_symbol_hook
5241 #define elf_backend_symbol_processing \
5242   elf_x86_64_symbol_processing
5243 #define elf_backend_common_section_index \
5244   elf_x86_64_common_section_index
5245 #define elf_backend_common_section \
5246   elf_x86_64_common_section
5247 #define elf_backend_common_definition \
5248   elf_x86_64_common_definition
5249 #define elf_backend_merge_symbol \
5250   elf_x86_64_merge_symbol
5251 #define elf_backend_special_sections \
5252   elf_x86_64_special_sections
5253 #define elf_backend_additional_program_headers \
5254   elf_x86_64_additional_program_headers
5255 #define elf_backend_hash_symbol \
5256   elf_x86_64_hash_symbol
5257
5258 #define elf_backend_post_process_headers  _bfd_elf_set_osabi
5259
5260 #include "elf64-target.h"
5261
5262 /* FreeBSD support.  */
5263
5264 #undef  TARGET_LITTLE_SYM
5265 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_freebsd_vec
5266 #undef  TARGET_LITTLE_NAME
5267 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
5268
5269 #undef  ELF_OSABI
5270 #define ELF_OSABI                           ELFOSABI_FREEBSD
5271
5272 #undef  elf64_bed
5273 #define elf64_bed elf64_x86_64_fbsd_bed
5274
5275 #include "elf64-target.h"
5276
5277 /* Solaris 2 support.  */
5278
5279 #undef  TARGET_LITTLE_SYM
5280 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_sol2_vec
5281 #undef  TARGET_LITTLE_NAME
5282 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
5283
5284 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5285    objects won't be recognized.  */
5286 #undef ELF_OSABI
5287
5288 #undef  elf64_bed
5289 #define elf64_bed                           elf64_x86_64_sol2_bed
5290
5291 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5292    boundary.  */
5293 #undef elf_backend_static_tls_alignment
5294 #define elf_backend_static_tls_alignment    16
5295
5296 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5297
5298    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5299    File, p.63.  */
5300 #undef elf_backend_want_plt_sym
5301 #define elf_backend_want_plt_sym            1
5302
5303 #include "elf64-target.h"
5304
5305 /* Native Client support.  */
5306
5307 #undef  TARGET_LITTLE_SYM
5308 #define TARGET_LITTLE_SYM               bfd_elf64_x86_64_nacl_vec
5309 #undef  TARGET_LITTLE_NAME
5310 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
5311 #undef  elf64_bed
5312 #define elf64_bed                       elf64_x86_64_nacl_bed
5313
5314 #undef  ELF_MAXPAGESIZE
5315 #undef  ELF_MINPAGESIZE
5316 #undef  ELF_COMMONPAGESIZE
5317 #define ELF_MAXPAGESIZE                 0x10000
5318 #define ELF_MINPAGESIZE                 0x10000
5319 #define ELF_COMMONPAGESIZE              0x10000
5320
5321 /* Restore defaults.  */
5322 #undef  ELF_OSABI
5323 #undef  elf_backend_static_tls_alignment
5324 #undef  elf_backend_want_plt_sym
5325 #define elf_backend_want_plt_sym        0
5326
5327 /* NaCl uses substantially different PLT entries for the same effects.  */
5328
5329 #undef  elf_backend_plt_alignment
5330 #define elf_backend_plt_alignment       5
5331 #define NACL_PLT_ENTRY_SIZE             64
5332 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5333
5334 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5335   {
5336     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
5337     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
5338     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5339     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5340     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5341
5342     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
5343     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5344
5345     /* 32 bytes of nop to pad out to the standard size.  */
5346     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5347     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
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     0x66,                                  /* excess data32 prefix      */
5351     0x90                                   /* nop */
5352   };
5353
5354 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5355   {
5356     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
5357     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5358     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5359     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5360
5361     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
5362     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5363     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5364
5365     /* Lazy GOT entries point here (32-byte aligned).  */
5366     0x68,                 /* pushq immediate */
5367     0, 0, 0, 0,           /* replaced with index into relocation table.  */
5368     0xe9,                 /* jmp relative */
5369     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
5370
5371     /* 22 bytes of nop to pad out to the standard size.  */
5372     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5373     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5374     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
5375   };
5376
5377 /* .eh_frame covering the .plt section.  */
5378
5379 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5380   {
5381 #if (PLT_CIE_LENGTH != 20                               \
5382      || PLT_FDE_LENGTH != 36                            \
5383      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5384      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5385 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5386 #endif
5387     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
5388     0, 0, 0, 0,                 /* CIE ID */
5389     1,                          /* CIE version */
5390     'z', 'R', 0,                /* Augmentation string */
5391     1,                          /* Code alignment factor */
5392     0x78,                       /* Data alignment factor */
5393     16,                         /* Return address column */
5394     1,                          /* Augmentation size */
5395     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5396     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5397     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
5398     DW_CFA_nop, DW_CFA_nop,
5399
5400     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
5401     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5402     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
5403     0, 0, 0, 0,                 /* .plt size goes here */
5404     0,                          /* Augmentation size */
5405     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
5406     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5407     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
5408     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5409     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
5410     13,                         /* Block length */
5411     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
5412     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
5413     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5414     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5415     DW_CFA_nop, DW_CFA_nop
5416   };
5417
5418 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5419   {
5420     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
5421     elf_x86_64_nacl_plt_entry,               /* plt_entry */
5422     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
5423     2,                                       /* plt0_got1_offset */
5424     9,                                       /* plt0_got2_offset */
5425     13,                                      /* plt0_got2_insn_end */
5426     3,                                       /* plt_got_offset */
5427     33,                                      /* plt_reloc_offset */
5428     38,                                      /* plt_plt_offset */
5429     7,                                       /* plt_got_insn_size */
5430     42,                                      /* plt_plt_insn_end */
5431     32,                                      /* plt_lazy_offset */
5432     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
5433     sizeof (elf_x86_64_nacl_eh_frame_plt),   /* eh_frame_plt_size */
5434   };
5435
5436 #undef  elf_backend_arch_data
5437 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
5438
5439 #undef  elf_backend_modify_segment_map
5440 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5441 #undef  elf_backend_modify_program_headers
5442 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5443
5444 #include "elf64-target.h"
5445
5446 /* Native Client x32 support.  */
5447
5448 #undef  TARGET_LITTLE_SYM
5449 #define TARGET_LITTLE_SYM               bfd_elf32_x86_64_nacl_vec
5450 #undef  TARGET_LITTLE_NAME
5451 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
5452 #undef  elf32_bed
5453 #define elf32_bed                       elf32_x86_64_nacl_bed
5454
5455 #define bfd_elf32_bfd_link_hash_table_create \
5456   elf_x86_64_link_hash_table_create
5457 #define bfd_elf32_bfd_link_hash_table_free \
5458   elf_x86_64_link_hash_table_free
5459 #define bfd_elf32_bfd_reloc_type_lookup \
5460   elf_x86_64_reloc_type_lookup
5461 #define bfd_elf32_bfd_reloc_name_lookup \
5462   elf_x86_64_reloc_name_lookup
5463 #define bfd_elf32_mkobject \
5464   elf_x86_64_mkobject
5465
5466 #undef elf_backend_object_p
5467 #define elf_backend_object_p \
5468   elf32_x86_64_elf_object_p
5469
5470 #undef elf_backend_bfd_from_remote_memory
5471 #define elf_backend_bfd_from_remote_memory \
5472   _bfd_elf32_bfd_from_remote_memory
5473
5474 #undef elf_backend_size_info
5475 #define elf_backend_size_info \
5476   _bfd_elf32_size_info
5477
5478 #include "elf32-target.h"
5479
5480 /* Restore defaults.  */
5481 #undef  elf_backend_object_p
5482 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5483 #undef  elf_backend_bfd_from_remote_memory
5484 #undef  elf_backend_size_info
5485 #undef  elf_backend_modify_segment_map
5486 #undef  elf_backend_modify_program_headers
5487
5488 /* Intel L1OM support.  */
5489
5490 static bfd_boolean
5491 elf64_l1om_elf_object_p (bfd *abfd)
5492 {
5493   /* Set the right machine number for an L1OM elf64 file.  */
5494   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5495   return TRUE;
5496 }
5497
5498 #undef  TARGET_LITTLE_SYM
5499 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_vec
5500 #undef  TARGET_LITTLE_NAME
5501 #define TARGET_LITTLE_NAME                  "elf64-l1om"
5502 #undef ELF_ARCH
5503 #define ELF_ARCH                            bfd_arch_l1om
5504
5505 #undef  ELF_MACHINE_CODE
5506 #define ELF_MACHINE_CODE                    EM_L1OM
5507
5508 #undef  ELF_OSABI
5509
5510 #undef  elf64_bed
5511 #define elf64_bed elf64_l1om_bed
5512
5513 #undef elf_backend_object_p
5514 #define elf_backend_object_p                elf64_l1om_elf_object_p
5515
5516 /* Restore defaults.  */
5517 #undef  ELF_MAXPAGESIZE
5518 #undef  ELF_MINPAGESIZE
5519 #undef  ELF_COMMONPAGESIZE
5520 #define ELF_MAXPAGESIZE                 0x200000
5521 #define ELF_MINPAGESIZE                 0x1000
5522 #define ELF_COMMONPAGESIZE              0x1000
5523 #undef  elf_backend_plt_alignment
5524 #define elf_backend_plt_alignment       4
5525 #undef  elf_backend_arch_data
5526 #define elf_backend_arch_data   &elf_x86_64_arch_bed
5527
5528 #include "elf64-target.h"
5529
5530 /* FreeBSD L1OM support.  */
5531
5532 #undef  TARGET_LITTLE_SYM
5533 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_freebsd_vec
5534 #undef  TARGET_LITTLE_NAME
5535 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
5536
5537 #undef  ELF_OSABI
5538 #define ELF_OSABI                           ELFOSABI_FREEBSD
5539
5540 #undef  elf64_bed
5541 #define elf64_bed elf64_l1om_fbsd_bed
5542
5543 #include "elf64-target.h"
5544
5545 /* Intel K1OM support.  */
5546
5547 static bfd_boolean
5548 elf64_k1om_elf_object_p (bfd *abfd)
5549 {
5550   /* Set the right machine number for an K1OM elf64 file.  */
5551   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5552   return TRUE;
5553 }
5554
5555 #undef  TARGET_LITTLE_SYM
5556 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_vec
5557 #undef  TARGET_LITTLE_NAME
5558 #define TARGET_LITTLE_NAME                  "elf64-k1om"
5559 #undef ELF_ARCH
5560 #define ELF_ARCH                            bfd_arch_k1om
5561
5562 #undef  ELF_MACHINE_CODE
5563 #define ELF_MACHINE_CODE                    EM_K1OM
5564
5565 #undef  ELF_OSABI
5566
5567 #undef  elf64_bed
5568 #define elf64_bed elf64_k1om_bed
5569
5570 #undef elf_backend_object_p
5571 #define elf_backend_object_p                elf64_k1om_elf_object_p
5572
5573 #undef  elf_backend_static_tls_alignment
5574
5575 #undef elf_backend_want_plt_sym
5576 #define elf_backend_want_plt_sym            0
5577
5578 #include "elf64-target.h"
5579
5580 /* FreeBSD K1OM support.  */
5581
5582 #undef  TARGET_LITTLE_SYM
5583 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_freebsd_vec
5584 #undef  TARGET_LITTLE_NAME
5585 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
5586
5587 #undef  ELF_OSABI
5588 #define ELF_OSABI                           ELFOSABI_FREEBSD
5589
5590 #undef  elf64_bed
5591 #define elf64_bed elf64_k1om_fbsd_bed
5592
5593 #include "elf64-target.h"
5594
5595 /* 32bit x86-64 support.  */
5596
5597 #undef  TARGET_LITTLE_SYM
5598 #define TARGET_LITTLE_SYM                   bfd_elf32_x86_64_vec
5599 #undef  TARGET_LITTLE_NAME
5600 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
5601 #undef  elf32_bed
5602
5603 #undef ELF_ARCH
5604 #define ELF_ARCH                            bfd_arch_i386
5605
5606 #undef  ELF_MACHINE_CODE
5607 #define ELF_MACHINE_CODE                    EM_X86_64
5608
5609 #undef  ELF_OSABI
5610
5611 #undef elf_backend_object_p
5612 #define elf_backend_object_p \
5613   elf32_x86_64_elf_object_p
5614
5615 #undef elf_backend_bfd_from_remote_memory
5616 #define elf_backend_bfd_from_remote_memory \
5617   _bfd_elf32_bfd_from_remote_memory
5618
5619 #undef elf_backend_size_info
5620 #define elf_backend_size_info \
5621   _bfd_elf32_size_info
5622
5623 #include "elf32-target.h"