bfd/elf64-x86-64.c

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