contrib/gdb-7/bfd/elf64-x86-64.c

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