bfd/elf64-x86-64.c

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