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