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 (_("%pB: unsupported relocation type %#x"),
 286                               abfd, 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         (_("%pB: TLS transition from %s to %s against `%s' at %#" PRIx64
1336            " in section `%pA' failed"),
1337          abfd, from->name, to->name, name, (uint64_t) 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 (_("%pB: 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 (_("%pB: 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                   (_("%pB: 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                       (_("%pB: '%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                     {
2139                       h->pointer_equality_needed = 1;
2140                       if (bfd_link_pie (info)
2141                           && h->type == STT_FUNC
2142                           && !h->def_regular
2143                           && h->def_dynamic)
2144                         {
2145                           h->needs_plt = 1;
2146                           h->plt.refcount = 1;
2147                         }
2148                     }
2149                 }
2150               else if (r_type != R_X86_64_PC32_BND
2151                        && r_type != R_X86_64_PC64)
2152                 {
2153                   h->pointer_equality_needed = 1;
2154                   /* At run-time, R_X86_64_64 can be resolved for both
2155                      x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2156                      can only be resolved for x32.  */
2157                   if ((sec->flags & SEC_READONLY) == 0
2158                       && (r_type == R_X86_64_64
2159                           || (!ABI_64_P (abfd)
2160                               && (r_type == R_X86_64_32
2161                                   || r_type == R_X86_64_32S))))
2162                     func_pointer_ref = TRUE;
2163                 }
2164
2165               if (!func_pointer_ref)
2166                 {
2167                   /* If this reloc is in a read-only section, we might
2168                      need a copy reloc.  We can't check reliably at this
2169                      stage whether the section is read-only, as input
2170                      sections have not yet been mapped to output sections.
2171                      Tentatively set the flag for now, and correct in
2172                      adjust_dynamic_symbol.  */
2173                   h->non_got_ref = 1;
2174
2175                   /* We may need a .plt entry if the symbol is a function
2176                      defined in a shared lib or is a function referenced
2177                      from the code or read-only section.  */
2178                   if (!h->def_regular
2179                       || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2180                     h->plt.refcount = 1;
2181                 }
2182             }
2183
2184           size_reloc = FALSE;
2185 do_size:
2186           if (NEED_DYNAMIC_RELOCATION_P (info, TRUE, h, sec, r_type,
2187                                          htab->pointer_r_type))
2188             {
2189               struct elf_dyn_relocs *p;
2190               struct elf_dyn_relocs **head;
2191
2192               /* We must copy these reloc types into the output file.
2193                  Create a reloc section in dynobj and make room for
2194                  this reloc.  */
2195               if (sreloc == NULL)
2196                 {
2197                   sreloc = _bfd_elf_make_dynamic_reloc_section
2198                     (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2199                      abfd, /*rela?*/ TRUE);
2200
2201                   if (sreloc == NULL)
2202                     goto error_return;
2203                 }
2204
2205               /* If this is a global symbol, we count the number of
2206                  relocations we need for this symbol.  */
2207               if (h != NULL)
2208                 head = &eh->dyn_relocs;
2209               else
2210                 {
2211                   /* Track dynamic relocs needed for local syms too.
2212                      We really need local syms available to do this
2213                      easily.  Oh well.  */
2214                   asection *s;
2215                   void **vpp;
2216
2217                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2218                                                 abfd, r_symndx);
2219                   if (isym == NULL)
2220                     goto error_return;
2221
2222                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2223                   if (s == NULL)
2224                     s = sec;
2225
2226                   /* Beware of type punned pointers vs strict aliasing
2227                      rules.  */
2228                   vpp = &(elf_section_data (s)->local_dynrel);
2229                   head = (struct elf_dyn_relocs **)vpp;
2230                 }
2231
2232               p = *head;
2233               if (p == NULL || p->sec != sec)
2234                 {
2235                   bfd_size_type amt = sizeof *p;
2236
2237                   p = ((struct elf_dyn_relocs *)
2238                        bfd_alloc (htab->elf.dynobj, amt));
2239                   if (p == NULL)
2240                     goto error_return;
2241                   p->next = *head;
2242                   *head = p;
2243                   p->sec = sec;
2244                   p->count = 0;
2245                   p->pc_count = 0;
2246                 }
2247
2248               p->count += 1;
2249               /* Count size relocation as PC-relative relocation.  */
2250               if (X86_PCREL_TYPE_P (r_type) || size_reloc)
2251                 p->pc_count += 1;
2252             }
2253           break;
2254
2255           /* This relocation describes the C++ object vtable hierarchy.
2256              Reconstruct it for later use during GC.  */
2257         case R_X86_64_GNU_VTINHERIT:
2258           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2259             goto error_return;
2260           break;
2261
2262           /* This relocation describes which C++ vtable entries are actually
2263              used.  Record for later use during GC.  */
2264         case R_X86_64_GNU_VTENTRY:
2265           BFD_ASSERT (h != NULL);
2266           if (h != NULL
2267               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2268             goto error_return;
2269           break;
2270
2271         default:
2272           break;
2273         }
2274     }
2275
2276   if (elf_section_data (sec)->this_hdr.contents != contents)
2277     {
2278       if (!converted && !info->keep_memory)
2279         free (contents);
2280       else
2281         {
2282           /* Cache the section contents for elf_link_input_bfd if any
2283              load is converted or --no-keep-memory isn't used.  */
2284           elf_section_data (sec)->this_hdr.contents = contents;
2285         }
2286     }
2287
2288   /* Cache relocations if any load is converted.  */
2289   if (elf_section_data (sec)->relocs != relocs && converted)
2290     elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
2291
2292   return TRUE;
2293
2294 error_return:
2295   if (elf_section_data (sec)->this_hdr.contents != contents)
2296     free (contents);
2297   sec->check_relocs_failed = 1;
2298   return FALSE;
2299 }
2300
2301 /* Return the relocation value for @tpoff relocation
2302    if STT_TLS virtual address is ADDRESS.  */
2303
2304 static bfd_vma
2305 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2306 {
2307   struct elf_link_hash_table *htab = elf_hash_table (info);
2308   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2309   bfd_vma static_tls_size;
2310
2311   /* If tls_segment is NULL, we should have signalled an error already.  */
2312   if (htab->tls_sec == NULL)
2313     return 0;
2314
2315   /* Consider special static TLS alignment requirements.  */
2316   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2317   return address - static_tls_size - htab->tls_sec->vma;
2318 }
2319
2320 /* Relocate an x86_64 ELF section.  */
2321
2322 static bfd_boolean
2323 elf_x86_64_relocate_section (bfd *output_bfd,
2324                              struct bfd_link_info *info,
2325                              bfd *input_bfd,
2326                              asection *input_section,
2327                              bfd_byte *contents,
2328                              Elf_Internal_Rela *relocs,
2329                              Elf_Internal_Sym *local_syms,
2330                              asection **local_sections)
2331 {
2332   struct elf_x86_link_hash_table *htab;
2333   Elf_Internal_Shdr *symtab_hdr;
2334   struct elf_link_hash_entry **sym_hashes;
2335   bfd_vma *local_got_offsets;
2336   bfd_vma *local_tlsdesc_gotents;
2337   Elf_Internal_Rela *rel;
2338   Elf_Internal_Rela *wrel;
2339   Elf_Internal_Rela *relend;
2340   unsigned int plt_entry_size;
2341
2342   /* Skip if check_relocs failed.  */
2343   if (input_section->check_relocs_failed)
2344     return FALSE;
2345
2346   htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
2347   if (htab == NULL)
2348     return FALSE;
2349
2350   BFD_ASSERT (is_x86_elf (input_bfd, htab));
2351
2352   plt_entry_size = htab->plt.plt_entry_size;
2353   symtab_hdr = &elf_symtab_hdr (input_bfd);
2354   sym_hashes = elf_sym_hashes (input_bfd);
2355   local_got_offsets = elf_local_got_offsets (input_bfd);
2356   local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2357
2358   _bfd_x86_elf_set_tls_module_base (info);
2359
2360   rel = wrel = relocs;
2361   relend = relocs + input_section->reloc_count;
2362   for (; rel < relend; wrel++, rel++)
2363     {
2364       unsigned int r_type, r_type_tls;
2365       reloc_howto_type *howto;
2366       unsigned long r_symndx;
2367       struct elf_link_hash_entry *h;
2368       struct elf_x86_link_hash_entry *eh;
2369       Elf_Internal_Sym *sym;
2370       asection *sec;
2371       bfd_vma off, offplt, plt_offset;
2372       bfd_vma relocation;
2373       bfd_boolean unresolved_reloc;
2374       bfd_reloc_status_type r;
2375       int tls_type;
2376       asection *base_got, *resolved_plt;
2377       bfd_vma st_size;
2378       bfd_boolean resolved_to_zero;
2379       bfd_boolean relative_reloc;
2380       bfd_boolean converted_reloc;
2381       bfd_boolean need_copy_reloc_in_pie;
2382
2383       r_type = ELF32_R_TYPE (rel->r_info);
2384       if (r_type == (int) R_X86_64_GNU_VTINHERIT
2385           || r_type == (int) R_X86_64_GNU_VTENTRY)
2386         {
2387           if (wrel != rel)
2388             *wrel = *rel;
2389           continue;
2390         }
2391
2392       converted_reloc = (r_type & R_X86_64_converted_reloc_bit) != 0;
2393       r_type &= ~R_X86_64_converted_reloc_bit;
2394
2395       if (r_type >= (int) R_X86_64_standard)
2396         return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2397
2398       if (r_type != (int) R_X86_64_32
2399           || ABI_64_P (output_bfd))
2400         howto = x86_64_elf_howto_table + r_type;
2401       else
2402         howto = (x86_64_elf_howto_table
2403                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
2404       r_symndx = htab->r_sym (rel->r_info);
2405       h = NULL;
2406       sym = NULL;
2407       sec = NULL;
2408       unresolved_reloc = FALSE;
2409       if (r_symndx < symtab_hdr->sh_info)
2410         {
2411           sym = local_syms + r_symndx;
2412           sec = local_sections[r_symndx];
2413
2414           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
2415                                                 &sec, rel);
2416           st_size = sym->st_size;
2417
2418           /* Relocate against local STT_GNU_IFUNC symbol.  */
2419           if (!bfd_link_relocatable (info)
2420               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2421             {
2422               h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd,
2423                                                    rel, FALSE);
2424               if (h == NULL)
2425                 abort ();
2426
2427               /* Set STT_GNU_IFUNC symbol value.  */
2428               h->root.u.def.value = sym->st_value;
2429               h->root.u.def.section = sec;
2430             }
2431         }
2432       else
2433         {
2434           bfd_boolean warned ATTRIBUTE_UNUSED;
2435           bfd_boolean ignored ATTRIBUTE_UNUSED;
2436
2437           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2438                                    r_symndx, symtab_hdr, sym_hashes,
2439                                    h, sec, relocation,
2440                                    unresolved_reloc, warned, ignored);
2441           st_size = h->size;
2442         }
2443
2444       if (sec != NULL && discarded_section (sec))
2445         {
2446           _bfd_clear_contents (howto, input_bfd, input_section,
2447                                contents + rel->r_offset);
2448           wrel->r_offset = rel->r_offset;
2449           wrel->r_info = 0;
2450           wrel->r_addend = 0;
2451
2452           /* For ld -r, remove relocations in debug sections against
2453              sections defined in discarded sections.  Not done for
2454              eh_frame editing code expects to be present.  */
2455            if (bfd_link_relocatable (info)
2456                && (input_section->flags & SEC_DEBUGGING))
2457              wrel--;
2458
2459           continue;
2460         }
2461
2462       if (bfd_link_relocatable (info))
2463         {
2464           if (wrel != rel)
2465             *wrel = *rel;
2466           continue;
2467         }
2468
2469       if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
2470         {
2471           if (r_type == R_X86_64_64)
2472             {
2473               /* For x32, treat R_X86_64_64 like R_X86_64_32 and
2474                  zero-extend it to 64bit if addend is zero.  */
2475               r_type = R_X86_64_32;
2476               memset (contents + rel->r_offset + 4, 0, 4);
2477             }
2478           else if (r_type == R_X86_64_SIZE64)
2479             {
2480               /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
2481                  zero-extend it to 64bit if addend is zero.  */
2482               r_type = R_X86_64_SIZE32;
2483               memset (contents + rel->r_offset + 4, 0, 4);
2484             }
2485         }
2486
2487       eh = (struct elf_x86_link_hash_entry *) h;
2488
2489       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2490          it here if it is defined in a non-shared object.  */
2491       if (h != NULL
2492           && h->type == STT_GNU_IFUNC
2493           && h->def_regular)
2494         {
2495           bfd_vma plt_index;
2496           const char *name;
2497
2498           if ((input_section->flags & SEC_ALLOC) == 0)
2499             {
2500               /* Dynamic relocs are not propagated for SEC_DEBUGGING
2501                  sections because such sections are not SEC_ALLOC and
2502                  thus ld.so will not process them.  */
2503               if ((input_section->flags & SEC_DEBUGGING) != 0)
2504                 continue;
2505               abort ();
2506             }
2507
2508           switch (r_type)
2509             {
2510             default:
2511               break;
2512
2513             case R_X86_64_GOTPCREL:
2514             case R_X86_64_GOTPCRELX:
2515             case R_X86_64_REX_GOTPCRELX:
2516             case R_X86_64_GOTPCREL64:
2517               base_got = htab->elf.sgot;
2518               off = h->got.offset;
2519
2520               if (base_got == NULL)
2521                 abort ();
2522
2523               if (off == (bfd_vma) -1)
2524                 {
2525                   /* We can't use h->got.offset here to save state, or
2526                      even just remember the offset, as finish_dynamic_symbol
2527                      would use that as offset into .got.  */
2528
2529                   if (h->plt.offset == (bfd_vma) -1)
2530                     abort ();
2531
2532                   if (htab->elf.splt != NULL)
2533                     {
2534                       plt_index = (h->plt.offset / plt_entry_size
2535                                    - htab->plt.has_plt0);
2536                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
2537                       base_got = htab->elf.sgotplt;
2538                     }
2539                   else
2540                     {
2541                       plt_index = h->plt.offset / plt_entry_size;
2542                       off = plt_index * GOT_ENTRY_SIZE;
2543                       base_got = htab->elf.igotplt;
2544                     }
2545
2546                   if (h->dynindx == -1
2547                       || h->forced_local
2548                       || info->symbolic)
2549                     {
2550                       /* This references the local defitionion.  We must
2551                          initialize this entry in the global offset table.
2552                          Since the offset must always be a multiple of 8,
2553                          we use the least significant bit to record
2554                          whether we have initialized it already.
2555
2556                          When doing a dynamic link, we create a .rela.got
2557                          relocation entry to initialize the value.  This
2558                          is done in the finish_dynamic_symbol routine.   */
2559                       if ((off & 1) != 0)
2560                         off &= ~1;
2561                       else
2562                         {
2563                           bfd_put_64 (output_bfd, relocation,
2564                                       base_got->contents + off);
2565                           /* Note that this is harmless for the GOTPLT64
2566                              case, as -1 | 1 still is -1.  */
2567                           h->got.offset |= 1;
2568                         }
2569                     }
2570                 }
2571
2572               relocation = (base_got->output_section->vma
2573                             + base_got->output_offset + off);
2574
2575               goto do_relocation;
2576             }
2577
2578           if (h->plt.offset == (bfd_vma) -1)
2579             {
2580               /* Handle static pointers of STT_GNU_IFUNC symbols.  */
2581               if (r_type == htab->pointer_r_type
2582                   && (input_section->flags & SEC_CODE) == 0)
2583                 goto do_ifunc_pointer;
2584               goto bad_ifunc_reloc;
2585             }
2586
2587           /* STT_GNU_IFUNC symbol must go through PLT.  */
2588           if (htab->elf.splt != NULL)
2589             {
2590               if (htab->plt_second != NULL)
2591                 {
2592                   resolved_plt = htab->plt_second;
2593                   plt_offset = eh->plt_second.offset;
2594                 }
2595               else
2596                 {
2597                   resolved_plt = htab->elf.splt;
2598                   plt_offset =  h->plt.offset;
2599                 }
2600             }
2601           else
2602             {
2603               resolved_plt = htab->elf.iplt;
2604               plt_offset =  h->plt.offset;
2605             }
2606
2607           relocation = (resolved_plt->output_section->vma
2608                         + resolved_plt->output_offset + plt_offset);
2609
2610           switch (r_type)
2611             {
2612             default:
2613 bad_ifunc_reloc:
2614               if (h->root.root.string)
2615                 name = h->root.root.string;
2616               else
2617                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2618                                          NULL);
2619               _bfd_error_handler
2620                 /* xgettext:c-format */
2621                 (_("%pB: relocation %s against STT_GNU_IFUNC "
2622                    "symbol `%s' isn't supported"), input_bfd,
2623                  howto->name, name);
2624               bfd_set_error (bfd_error_bad_value);
2625               return FALSE;
2626
2627             case R_X86_64_32S:
2628               if (bfd_link_pic (info))
2629                 abort ();
2630               goto do_relocation;
2631
2632             case R_X86_64_32:
2633               if (ABI_64_P (output_bfd))
2634                 goto do_relocation;
2635               /* FALLTHROUGH */
2636             case R_X86_64_64:
2637 do_ifunc_pointer:
2638               if (rel->r_addend != 0)
2639                 {
2640                   if (h->root.root.string)
2641                     name = h->root.root.string;
2642                   else
2643                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
2644                                              sym, NULL);
2645                   _bfd_error_handler
2646                     /* xgettext:c-format */
2647                     (_("%pB: relocation %s against STT_GNU_IFUNC "
2648                        "symbol `%s' has non-zero addend: %" PRId64),
2649                      input_bfd, howto->name, name, (int64_t) rel->r_addend);
2650                   bfd_set_error (bfd_error_bad_value);
2651                   return FALSE;
2652                 }
2653
2654               /* Generate dynamic relcoation only when there is a
2655                  non-GOT reference in a shared object or there is no
2656                  PLT.  */
2657               if ((bfd_link_pic (info) && h->non_got_ref)
2658                   || h->plt.offset == (bfd_vma) -1)
2659                 {
2660                   Elf_Internal_Rela outrel;
2661                   asection *sreloc;
2662
2663                   /* Need a dynamic relocation to get the real function
2664                      address.  */
2665                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2666                                                              info,
2667                                                              input_section,
2668                                                              rel->r_offset);
2669                   if (outrel.r_offset == (bfd_vma) -1
2670                       || outrel.r_offset == (bfd_vma) -2)
2671                     abort ();
2672
2673                   outrel.r_offset += (input_section->output_section->vma
2674                                       + input_section->output_offset);
2675
2676                   if (POINTER_LOCAL_IFUNC_P (info, h))
2677                     {
2678                       info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
2679                                               h->root.root.string,
2680                                               h->root.u.def.section->owner);
2681
2682                       /* This symbol is resolved locally.  */
2683                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
2684                       outrel.r_addend = (h->root.u.def.value
2685                                          + h->root.u.def.section->output_section->vma
2686                                          + h->root.u.def.section->output_offset);
2687                     }
2688                   else
2689                     {
2690                       outrel.r_info = htab->r_info (h->dynindx, r_type);
2691                       outrel.r_addend = 0;
2692                     }
2693
2694                   /* Dynamic relocations are stored in
2695                      1. .rela.ifunc section in PIC object.
2696                      2. .rela.got section in dynamic executable.
2697                      3. .rela.iplt section in static executable.  */
2698                   if (bfd_link_pic (info))
2699                     sreloc = htab->elf.irelifunc;
2700                   else if (htab->elf.splt != NULL)
2701                     sreloc = htab->elf.srelgot;
2702                   else
2703                     sreloc = htab->elf.irelplt;
2704                   elf_append_rela (output_bfd, sreloc, &outrel);
2705
2706                   /* If this reloc is against an external symbol, we
2707                      do not want to fiddle with the addend.  Otherwise,
2708                      we need to include the symbol value so that it
2709                      becomes an addend for the dynamic reloc.  For an
2710                      internal symbol, we have updated addend.  */
2711                   continue;
2712                 }
2713               /* FALLTHROUGH */
2714             case R_X86_64_PC32:
2715             case R_X86_64_PC32_BND:
2716             case R_X86_64_PC64:
2717             case R_X86_64_PLT32:
2718             case R_X86_64_PLT32_BND:
2719               goto do_relocation;
2720             }
2721         }
2722
2723       resolved_to_zero = (eh != NULL
2724                           && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2725
2726       /* When generating a shared object, the relocations handled here are
2727          copied into the output file to be resolved at run time.  */
2728       switch (r_type)
2729         {
2730         case R_X86_64_GOT32:
2731         case R_X86_64_GOT64:
2732           /* Relocation is to the entry for this symbol in the global
2733              offset table.  */
2734         case R_X86_64_GOTPCREL:
2735         case R_X86_64_GOTPCRELX:
2736         case R_X86_64_REX_GOTPCRELX:
2737         case R_X86_64_GOTPCREL64:
2738           /* Use global offset table entry as symbol value.  */
2739         case R_X86_64_GOTPLT64:
2740           /* This is obsolete and treated the same as GOT64.  */
2741           base_got = htab->elf.sgot;
2742
2743           if (htab->elf.sgot == NULL)
2744             abort ();
2745
2746           relative_reloc = FALSE;
2747           if (h != NULL)
2748             {
2749               off = h->got.offset;
2750               if (h->needs_plt
2751                   && h->plt.offset != (bfd_vma)-1
2752                   && off == (bfd_vma)-1)
2753                 {
2754                   /* We can't use h->got.offset here to save
2755                      state, or even just remember the offset, as
2756                      finish_dynamic_symbol would use that as offset into
2757                      .got.  */
2758                   bfd_vma plt_index = (h->plt.offset / plt_entry_size
2759                                        - htab->plt.has_plt0);
2760                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
2761                   base_got = htab->elf.sgotplt;
2762                 }
2763
2764               if (RESOLVED_LOCALLY_P (info, h, htab))
2765                 {
2766                   /* We must initialize this entry in the global offset
2767                      table.  Since the offset must always be a multiple
2768                      of 8, we use the least significant bit to record
2769                      whether we have initialized it already.
2770
2771                      When doing a dynamic link, we create a .rela.got
2772                      relocation entry to initialize the value.  This is
2773                      done in the finish_dynamic_symbol routine.  */
2774                   if ((off & 1) != 0)
2775                     off &= ~1;
2776                   else
2777                     {
2778                       bfd_put_64 (output_bfd, relocation,
2779                                   base_got->contents + off);
2780                       /* Note that this is harmless for the GOTPLT64 case,
2781                          as -1 | 1 still is -1.  */
2782                       h->got.offset |= 1;
2783
2784                       if (GENERATE_RELATIVE_RELOC_P (info, h))
2785                         {
2786                           /* If this symbol isn't dynamic in PIC,
2787                              generate R_X86_64_RELATIVE here.  */
2788                           eh->no_finish_dynamic_symbol = 1;
2789                           relative_reloc = TRUE;
2790                         }
2791                     }
2792                 }
2793               else
2794                 unresolved_reloc = FALSE;
2795             }
2796           else
2797             {
2798               if (local_got_offsets == NULL)
2799                 abort ();
2800
2801               off = local_got_offsets[r_symndx];
2802
2803               /* The offset must always be a multiple of 8.  We use
2804                  the least significant bit to record whether we have
2805                  already generated the necessary reloc.  */
2806               if ((off & 1) != 0)
2807                 off &= ~1;
2808               else
2809                 {
2810                   bfd_put_64 (output_bfd, relocation,
2811                               base_got->contents + off);
2812                   local_got_offsets[r_symndx] |= 1;
2813
2814                   if (bfd_link_pic (info))
2815                     relative_reloc = TRUE;
2816                 }
2817             }
2818
2819           if (relative_reloc)
2820             {
2821               asection *s;
2822               Elf_Internal_Rela outrel;
2823
2824               /* We need to generate a R_X86_64_RELATIVE reloc
2825                  for the dynamic linker.  */
2826               s = htab->elf.srelgot;
2827               if (s == NULL)
2828                 abort ();
2829
2830               outrel.r_offset = (base_got->output_section->vma
2831                                  + base_got->output_offset
2832                                  + off);
2833               outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
2834               outrel.r_addend = relocation;
2835               elf_append_rela (output_bfd, s, &outrel);
2836             }
2837
2838           if (off >= (bfd_vma) -2)
2839             abort ();
2840
2841           relocation = base_got->output_section->vma
2842                        + base_got->output_offset + off;
2843           if (r_type != R_X86_64_GOTPCREL
2844               && r_type != R_X86_64_GOTPCRELX
2845               && r_type != R_X86_64_REX_GOTPCRELX
2846               && r_type != R_X86_64_GOTPCREL64)
2847             relocation -= htab->elf.sgotplt->output_section->vma
2848                           - htab->elf.sgotplt->output_offset;
2849
2850           break;
2851
2852         case R_X86_64_GOTOFF64:
2853           /* Relocation is relative to the start of the global offset
2854              table.  */
2855
2856           /* Check to make sure it isn't a protected function or data
2857              symbol for shared library since it may not be local when
2858              used as function address or with copy relocation.  We also
2859              need to make sure that a symbol is referenced locally.  */
2860           if (bfd_link_pic (info) && h)
2861             {
2862               if (!h->def_regular)
2863                 {
2864                   const char *v;
2865
2866                   switch (ELF_ST_VISIBILITY (h->other))
2867                     {
2868                     case STV_HIDDEN:
2869                       v = _("hidden symbol");
2870                       break;
2871                     case STV_INTERNAL:
2872                       v = _("internal symbol");
2873                       break;
2874                     case STV_PROTECTED:
2875                       v = _("protected symbol");
2876                       break;
2877                     default:
2878                       v = _("symbol");
2879                       break;
2880                     }
2881
2882                   _bfd_error_handler
2883                     /* xgettext:c-format */
2884                     (_("%pB: relocation R_X86_64_GOTOFF64 against undefined %s"
2885                        " `%s' can not be used when making a shared object"),
2886                      input_bfd, v, h->root.root.string);
2887                   bfd_set_error (bfd_error_bad_value);
2888                   return FALSE;
2889                 }
2890               else if (!bfd_link_executable (info)
2891                        && !SYMBOL_REFERENCES_LOCAL_P (info, h)
2892                        && (h->type == STT_FUNC
2893                            || h->type == STT_OBJECT)
2894                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2895                 {
2896                   _bfd_error_handler
2897               /* xgettext:c-format */
2898                     (_("%pB: relocation R_X86_64_GOTOFF64 against protected %s"
2899                        " `%s' can not be used when making a shared object"),
2900                      input_bfd,
2901                      h->type == STT_FUNC ? "function" : "data",
2902                      h->root.root.string);
2903                   bfd_set_error (bfd_error_bad_value);
2904               return FALSE;
2905                 }
2906             }
2907
2908           /* Note that sgot is not involved in this
2909              calculation.  We always want the start of .got.plt.  If we
2910              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2911              permitted by the ABI, we might have to change this
2912              calculation.  */
2913           relocation -= htab->elf.sgotplt->output_section->vma
2914                         + htab->elf.sgotplt->output_offset;
2915           break;
2916
2917         case R_X86_64_GOTPC32:
2918         case R_X86_64_GOTPC64:
2919           /* Use global offset table as symbol value.  */
2920           relocation = htab->elf.sgotplt->output_section->vma
2921                        + htab->elf.sgotplt->output_offset;
2922           unresolved_reloc = FALSE;
2923           break;
2924
2925         case R_X86_64_PLTOFF64:
2926           /* Relocation is PLT entry relative to GOT.  For local
2927              symbols it's the symbol itself relative to GOT.  */
2928           if (h != NULL
2929               /* See PLT32 handling.  */
2930               && (h->plt.offset != (bfd_vma) -1
2931                   || eh->plt_got.offset != (bfd_vma) -1)
2932               && htab->elf.splt != NULL)
2933             {
2934               if (eh->plt_got.offset != (bfd_vma) -1)
2935                 {
2936                   /* Use the GOT PLT.  */
2937                   resolved_plt = htab->plt_got;
2938                   plt_offset = eh->plt_got.offset;
2939                 }
2940               else if (htab->plt_second != NULL)
2941                 {
2942                   resolved_plt = htab->plt_second;
2943                   plt_offset = eh->plt_second.offset;
2944                 }
2945               else
2946                 {
2947                   resolved_plt = htab->elf.splt;
2948                   plt_offset = h->plt.offset;
2949                 }
2950
2951               relocation = (resolved_plt->output_section->vma
2952                             + resolved_plt->output_offset
2953                             + plt_offset);
2954               unresolved_reloc = FALSE;
2955             }
2956
2957           relocation -= htab->elf.sgotplt->output_section->vma
2958                         + htab->elf.sgotplt->output_offset;
2959           break;
2960
2961         case R_X86_64_PLT32:
2962         case R_X86_64_PLT32_BND:
2963           /* Relocation is to the entry for this symbol in the
2964              procedure linkage table.  */
2965
2966           /* Resolve a PLT32 reloc against a local symbol directly,
2967              without using the procedure linkage table.  */
2968           if (h == NULL)
2969             break;
2970
2971           if ((h->plt.offset == (bfd_vma) -1
2972                && eh->plt_got.offset == (bfd_vma) -1)
2973               || htab->elf.splt == NULL)
2974             {
2975               /* We didn't make a PLT entry for this symbol.  This
2976                  happens when statically linking PIC code, or when
2977                  using -Bsymbolic.  */
2978               break;
2979             }
2980
2981 use_plt:
2982           if (h->plt.offset != (bfd_vma) -1)
2983             {
2984               if (htab->plt_second != NULL)
2985                 {
2986                   resolved_plt = htab->plt_second;
2987                   plt_offset = eh->plt_second.offset;
2988                 }
2989               else
2990                 {
2991                   resolved_plt = htab->elf.splt;
2992                   plt_offset = h->plt.offset;
2993                 }
2994             }
2995           else
2996             {
2997               /* Use the GOT PLT.  */
2998               resolved_plt = htab->plt_got;
2999               plt_offset = eh->plt_got.offset;
3000             }
3001
3002           relocation = (resolved_plt->output_section->vma
3003                         + resolved_plt->output_offset
3004                         + plt_offset);
3005           unresolved_reloc = FALSE;
3006           break;
3007
3008         case R_X86_64_SIZE32:
3009         case R_X86_64_SIZE64:
3010           /* Set to symbol size.  */
3011           relocation = st_size;
3012           goto direct;
3013
3014         case R_X86_64_PC8:
3015         case R_X86_64_PC16:
3016         case R_X86_64_PC32:
3017         case R_X86_64_PC32_BND:
3018           /* Don't complain about -fPIC if the symbol is undefined when
3019              building executable unless it is unresolved weak symbol,
3020              references a dynamic definition in PIE or -z nocopyreloc
3021              is used.  */
3022           if ((input_section->flags & SEC_ALLOC) != 0
3023               && (input_section->flags & SEC_READONLY) != 0
3024               && h != NULL
3025               && ((bfd_link_executable (info)
3026                    && ((h->root.type == bfd_link_hash_undefweak
3027                         && !resolved_to_zero)
3028                        || (bfd_link_pie (info)
3029                            && !h->def_regular
3030                            && h->def_dynamic)
3031                        || ((info->nocopyreloc
3032                             || (eh->def_protected
3033                                 && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3034                            && h->def_dynamic
3035                            && !(h->root.u.def.section->flags & SEC_CODE))))
3036                   || bfd_link_dll (info)))
3037             {
3038               bfd_boolean fail = FALSE;
3039               if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3040                 {
3041                   /* Symbol is referenced locally.  Make sure it is
3042                      defined locally.  */
3043                   fail = !(h->def_regular || ELF_COMMON_DEF_P (h));
3044                 }
3045               else if (!(bfd_link_pie (info)
3046                          && (h->needs_copy || eh->needs_copy)))
3047                 {
3048                   /* Symbol doesn't need copy reloc and isn't referenced
3049                      locally.  Address of protected function may not be
3050                      reachable at run-time.  */
3051                   fail = (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3052                           || (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
3053                               && h->type == STT_FUNC));
3054                 }
3055
3056               if (fail)
3057                 return elf_x86_64_need_pic (info, input_bfd, input_section,
3058                                             h, NULL, NULL, howto);
3059             }
3060           /* Since x86-64 has PC-relative PLT, we can use PLT in PIE
3061              as function address.  */
3062           else if (h != NULL
3063                    && (input_section->flags & SEC_CODE) == 0
3064                    && bfd_link_pie (info)
3065                    && h->type == STT_FUNC
3066                    && !h->def_regular
3067                    && h->def_dynamic)
3068             goto use_plt;
3069           /* Fall through.  */
3070
3071         case R_X86_64_8:
3072         case R_X86_64_16:
3073         case R_X86_64_32:
3074         case R_X86_64_PC64:
3075         case R_X86_64_64:
3076           /* FIXME: The ABI says the linker should make sure the value is
3077              the same when it's zeroextended to 64 bit.  */
3078
3079 direct:
3080           if ((input_section->flags & SEC_ALLOC) == 0)
3081             break;
3082
3083           need_copy_reloc_in_pie = (bfd_link_pie (info)
3084                                     && h != NULL
3085                                     && (h->needs_copy
3086                                         || eh->needs_copy
3087                                         || (h->root.type
3088                                             == bfd_link_hash_undefined))
3089                                     && (X86_PCREL_TYPE_P (r_type)
3090                                         || X86_SIZE_TYPE_P (r_type)));
3091
3092           if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type,
3093                                              need_copy_reloc_in_pie,
3094                                              resolved_to_zero, FALSE))
3095             {
3096               Elf_Internal_Rela outrel;
3097               bfd_boolean skip, relocate;
3098               asection *sreloc;
3099
3100               /* When generating a shared object, these relocations
3101                  are copied into the output file to be resolved at run
3102                  time.  */
3103               skip = FALSE;
3104               relocate = FALSE;
3105
3106               outrel.r_offset =
3107                 _bfd_elf_section_offset (output_bfd, info, input_section,
3108                                          rel->r_offset);
3109               if (outrel.r_offset == (bfd_vma) -1)
3110                 skip = TRUE;
3111               else if (outrel.r_offset == (bfd_vma) -2)
3112                 skip = TRUE, relocate = TRUE;
3113
3114               outrel.r_offset += (input_section->output_section->vma
3115                                   + input_section->output_offset);
3116
3117               if (skip)
3118                 memset (&outrel, 0, sizeof outrel);
3119
3120               else if (COPY_INPUT_RELOC_P (info, h, r_type))
3121                 {
3122                   outrel.r_info = htab->r_info (h->dynindx, r_type);
3123                   outrel.r_addend = rel->r_addend;
3124                 }
3125               else
3126                 {
3127                   /* This symbol is local, or marked to become local.
3128                      When relocation overflow check is disabled, we
3129                      convert R_X86_64_32 to dynamic R_X86_64_RELATIVE.  */
3130                   if (r_type == htab->pointer_r_type
3131                       || (r_type == R_X86_64_32
3132                           && info->no_reloc_overflow_check))
3133                     {
3134                       relocate = TRUE;
3135                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3136                       outrel.r_addend = relocation + rel->r_addend;
3137                     }
3138                   else if (r_type == R_X86_64_64
3139                            && !ABI_64_P (output_bfd))
3140                     {
3141                       relocate = TRUE;
3142                       outrel.r_info = htab->r_info (0,
3143                                                     R_X86_64_RELATIVE64);
3144                       outrel.r_addend = relocation + rel->r_addend;
3145                       /* Check addend overflow.  */
3146                       if ((outrel.r_addend & 0x80000000)
3147                           != (rel->r_addend & 0x80000000))
3148                         {
3149                           const char *name;
3150                           int addend = rel->r_addend;
3151                           if (h && h->root.root.string)
3152                             name = h->root.root.string;
3153                           else
3154                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3155                                                      sym, NULL);
3156                           _bfd_error_handler
3157                             /* xgettext:c-format */
3158                             (_("%pB: addend %s%#x in relocation %s against "
3159                                "symbol `%s' at %#" PRIx64
3160                                " in section `%pA' is out of range"),
3161                              input_bfd, addend < 0 ? "-" : "", addend,
3162                              howto->name, name, (uint64_t) rel->r_offset,
3163                              input_section);
3164                           bfd_set_error (bfd_error_bad_value);
3165                           return FALSE;
3166                         }
3167                     }
3168                   else
3169                     {
3170                       long sindx;
3171
3172                       if (bfd_is_abs_section (sec))
3173                         sindx = 0;
3174                       else if (sec == NULL || sec->owner == NULL)
3175                         {
3176                           bfd_set_error (bfd_error_bad_value);
3177                           return FALSE;
3178                         }
3179                       else
3180                         {
3181                           asection *osec;
3182
3183                           /* We are turning this relocation into one
3184                              against a section symbol.  It would be
3185                              proper to subtract the symbol's value,
3186                              osec->vma, from the emitted reloc addend,
3187                              but ld.so expects buggy relocs.  */
3188                           osec = sec->output_section;
3189                           sindx = elf_section_data (osec)->dynindx;
3190                           if (sindx == 0)
3191                             {
3192                               asection *oi = htab->elf.text_index_section;
3193                               sindx = elf_section_data (oi)->dynindx;
3194                             }
3195                           BFD_ASSERT (sindx != 0);
3196                         }
3197
3198                       outrel.r_info = htab->r_info (sindx, r_type);
3199                       outrel.r_addend = relocation + rel->r_addend;
3200                     }
3201                 }
3202
3203               sreloc = elf_section_data (input_section)->sreloc;
3204
3205               if (sreloc == NULL || sreloc->contents == NULL)
3206                 {
3207                   r = bfd_reloc_notsupported;
3208                   goto check_relocation_error;
3209                 }
3210
3211               elf_append_rela (output_bfd, sreloc, &outrel);
3212
3213               /* If this reloc is against an external symbol, we do
3214                  not want to fiddle with the addend.  Otherwise, we
3215                  need to include the symbol value so that it becomes
3216                  an addend for the dynamic reloc.  */
3217               if (! relocate)
3218                 continue;
3219             }
3220
3221           break;
3222
3223         case R_X86_64_TLSGD:
3224         case R_X86_64_GOTPC32_TLSDESC:
3225         case R_X86_64_TLSDESC_CALL:
3226         case R_X86_64_GOTTPOFF:
3227           tls_type = GOT_UNKNOWN;
3228           if (h == NULL && local_got_offsets)
3229             tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
3230           else if (h != NULL)
3231             tls_type = elf_x86_hash_entry (h)->tls_type;
3232
3233           r_type_tls = r_type;
3234           if (! elf_x86_64_tls_transition (info, input_bfd,
3235                                            input_section, contents,
3236                                            symtab_hdr, sym_hashes,
3237                                            &r_type_tls, tls_type, rel,
3238                                            relend, h, r_symndx, TRUE))
3239             return FALSE;
3240
3241           if (r_type_tls == R_X86_64_TPOFF32)
3242             {
3243               bfd_vma roff = rel->r_offset;
3244
3245               BFD_ASSERT (! unresolved_reloc);
3246
3247               if (r_type == R_X86_64_TLSGD)
3248                 {
3249                   /* GD->LE transition.  For 64bit, change
3250                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3251                         .word 0x6666; rex64; call __tls_get_addr@PLT
3252                      or
3253                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3254                         .byte 0x66; rex64
3255                         call *__tls_get_addr@GOTPCREL(%rip)
3256                         which may be converted to
3257                         addr32 call __tls_get_addr
3258                      into:
3259                         movq %fs:0, %rax
3260                         leaq foo@tpoff(%rax), %rax
3261                      For 32bit, change
3262                         leaq foo@tlsgd(%rip), %rdi
3263                         .word 0x6666; rex64; call __tls_get_addr@PLT
3264                      or
3265                         leaq foo@tlsgd(%rip), %rdi
3266                         .byte 0x66; rex64
3267                         call *__tls_get_addr@GOTPCREL(%rip)
3268                         which may be converted to
3269                         addr32 call __tls_get_addr
3270                      into:
3271                         movl %fs:0, %eax
3272                         leaq foo@tpoff(%rax), %rax
3273                      For largepic, change:
3274                         leaq foo@tlsgd(%rip), %rdi
3275                         movabsq $__tls_get_addr@pltoff, %rax
3276                         addq %r15, %rax
3277                         call *%rax
3278                      into:
3279                         movq %fs:0, %rax
3280                         leaq foo@tpoff(%rax), %rax
3281                         nopw 0x0(%rax,%rax,1)  */
3282                   int largepic = 0;
3283                   if (ABI_64_P (output_bfd))
3284                     {
3285                       if (contents[roff + 5] == 0xb8)
3286                         {
3287                           memcpy (contents + roff - 3,
3288                                   "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
3289                                   "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3290                           largepic = 1;
3291                         }
3292                       else
3293                         memcpy (contents + roff - 4,
3294                                 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3295                                 16);
3296                     }
3297                   else
3298                     memcpy (contents + roff - 3,
3299                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3300                             15);
3301                   bfd_put_32 (output_bfd,
3302                               elf_x86_64_tpoff (info, relocation),
3303                               contents + roff + 8 + largepic);
3304                   /* Skip R_X86_64_PC32, R_X86_64_PLT32,
3305                      R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64.  */
3306                   rel++;
3307                   wrel++;
3308                   continue;
3309                 }
3310               else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3311                 {
3312                   /* GDesc -> LE transition.
3313                      It's originally something like:
3314                      leaq x@tlsdesc(%rip), %rax
3315
3316                      Change it to:
3317                      movl $x@tpoff, %rax.  */
3318
3319                   unsigned int val, type;
3320
3321                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3322                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3323                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3324                              contents + roff - 3);
3325                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3326                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3327                              contents + roff - 1);
3328                   bfd_put_32 (output_bfd,
3329                               elf_x86_64_tpoff (info, relocation),
3330                               contents + roff);
3331                   continue;
3332                 }
3333               else if (r_type == R_X86_64_TLSDESC_CALL)
3334                 {
3335                   /* GDesc -> LE transition.
3336                      It's originally:
3337                      call *(%rax)
3338                      Turn it into:
3339                      xchg %ax,%ax.  */
3340                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3341                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3342                   continue;
3343                 }
3344               else if (r_type == R_X86_64_GOTTPOFF)
3345                 {
3346                   /* IE->LE transition:
3347                      For 64bit, originally it can be one of:
3348                      movq foo@gottpoff(%rip), %reg
3349                      addq foo@gottpoff(%rip), %reg
3350                      We change it into:
3351                      movq $foo, %reg
3352                      leaq foo(%reg), %reg
3353                      addq $foo, %reg.
3354                      For 32bit, originally it can be one of:
3355                      movq foo@gottpoff(%rip), %reg
3356                      addl foo@gottpoff(%rip), %reg
3357                      We change it into:
3358                      movq $foo, %reg
3359                      leal foo(%reg), %reg
3360                      addl $foo, %reg. */
3361
3362                   unsigned int val, type, reg;
3363
3364                   if (roff >= 3)
3365                     val = bfd_get_8 (input_bfd, contents + roff - 3);
3366                   else
3367                     val = 0;
3368                   type = bfd_get_8 (input_bfd, contents + roff - 2);
3369                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
3370                   reg >>= 3;
3371                   if (type == 0x8b)
3372                     {
3373                       /* movq */
3374                       if (val == 0x4c)
3375                         bfd_put_8 (output_bfd, 0x49,
3376                                    contents + roff - 3);
3377                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3378                         bfd_put_8 (output_bfd, 0x41,
3379                                    contents + roff - 3);
3380                       bfd_put_8 (output_bfd, 0xc7,
3381                                  contents + roff - 2);
3382                       bfd_put_8 (output_bfd, 0xc0 | reg,
3383                                  contents + roff - 1);
3384                     }
3385                   else if (reg == 4)
3386                     {
3387                       /* addq/addl -> addq/addl - addressing with %rsp/%r12
3388                          is special  */
3389                       if (val == 0x4c)
3390                         bfd_put_8 (output_bfd, 0x49,
3391                                    contents + roff - 3);
3392                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3393                         bfd_put_8 (output_bfd, 0x41,
3394                                    contents + roff - 3);
3395                       bfd_put_8 (output_bfd, 0x81,
3396                                  contents + roff - 2);
3397                       bfd_put_8 (output_bfd, 0xc0 | reg,
3398                                  contents + roff - 1);
3399                     }
3400                   else
3401                     {
3402                       /* addq/addl -> leaq/leal */
3403                       if (val == 0x4c)
3404                         bfd_put_8 (output_bfd, 0x4d,
3405                                    contents + roff - 3);
3406                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3407                         bfd_put_8 (output_bfd, 0x45,
3408                                    contents + roff - 3);
3409                       bfd_put_8 (output_bfd, 0x8d,
3410                                  contents + roff - 2);
3411                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3412                                  contents + roff - 1);
3413                     }
3414                   bfd_put_32 (output_bfd,
3415                               elf_x86_64_tpoff (info, relocation),
3416                               contents + roff);
3417                   continue;
3418                 }
3419               else
3420                 BFD_ASSERT (FALSE);
3421             }
3422
3423           if (htab->elf.sgot == NULL)
3424             abort ();
3425
3426           if (h != NULL)
3427             {
3428               off = h->got.offset;
3429               offplt = elf_x86_hash_entry (h)->tlsdesc_got;
3430             }
3431           else
3432             {
3433               if (local_got_offsets == NULL)
3434                 abort ();
3435
3436               off = local_got_offsets[r_symndx];
3437               offplt = local_tlsdesc_gotents[r_symndx];
3438             }
3439
3440           if ((off & 1) != 0)
3441             off &= ~1;
3442           else
3443             {
3444               Elf_Internal_Rela outrel;
3445               int dr_type, indx;
3446               asection *sreloc;
3447
3448               if (htab->elf.srelgot == NULL)
3449                 abort ();
3450
3451               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3452
3453               if (GOT_TLS_GDESC_P (tls_type))
3454                 {
3455                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3456                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3457                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3458                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3459                                      + htab->elf.sgotplt->output_offset
3460                                      + offplt
3461                                      + htab->sgotplt_jump_table_size);
3462                   sreloc = htab->elf.srelplt;
3463                   if (indx == 0)
3464                     outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3465                   else
3466                     outrel.r_addend = 0;
3467                   elf_append_rela (output_bfd, sreloc, &outrel);
3468                 }
3469
3470               sreloc = htab->elf.srelgot;
3471
3472               outrel.r_offset = (htab->elf.sgot->output_section->vma
3473                                  + htab->elf.sgot->output_offset + off);
3474
3475               if (GOT_TLS_GD_P (tls_type))
3476                 dr_type = R_X86_64_DTPMOD64;
3477               else if (GOT_TLS_GDESC_P (tls_type))
3478                 goto dr_done;
3479               else
3480                 dr_type = R_X86_64_TPOFF64;
3481
3482               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3483               outrel.r_addend = 0;
3484               if ((dr_type == R_X86_64_TPOFF64
3485                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
3486                 outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3487               outrel.r_info = htab->r_info (indx, dr_type);
3488
3489               elf_append_rela (output_bfd, sreloc, &outrel);
3490
3491               if (GOT_TLS_GD_P (tls_type))
3492                 {
3493                   if (indx == 0)
3494                     {
3495                       BFD_ASSERT (! unresolved_reloc);
3496                       bfd_put_64 (output_bfd,
3497                                   relocation - _bfd_x86_elf_dtpoff_base (info),
3498                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3499                     }
3500                   else
3501                     {
3502                       bfd_put_64 (output_bfd, 0,
3503                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3504                       outrel.r_info = htab->r_info (indx,
3505                                                     R_X86_64_DTPOFF64);
3506                       outrel.r_offset += GOT_ENTRY_SIZE;
3507                       elf_append_rela (output_bfd, sreloc,
3508                                                 &outrel);
3509                     }
3510                 }
3511
3512             dr_done:
3513               if (h != NULL)
3514                 h->got.offset |= 1;
3515               else
3516                 local_got_offsets[r_symndx] |= 1;
3517             }
3518
3519           if (off >= (bfd_vma) -2
3520               && ! GOT_TLS_GDESC_P (tls_type))
3521             abort ();
3522           if (r_type_tls == r_type)
3523             {
3524               if (r_type == R_X86_64_GOTPC32_TLSDESC
3525                   || r_type == R_X86_64_TLSDESC_CALL)
3526                 relocation = htab->elf.sgotplt->output_section->vma
3527                   + htab->elf.sgotplt->output_offset
3528                   + offplt + htab->sgotplt_jump_table_size;
3529               else
3530                 relocation = htab->elf.sgot->output_section->vma
3531                   + htab->elf.sgot->output_offset + off;
3532               unresolved_reloc = FALSE;
3533             }
3534           else
3535             {
3536               bfd_vma roff = rel->r_offset;
3537
3538               if (r_type == R_X86_64_TLSGD)
3539                 {
3540                   /* GD->IE transition.  For 64bit, change
3541                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3542                         .word 0x6666; rex64; call __tls_get_addr@PLT
3543                      or
3544                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3545                         .byte 0x66; rex64
3546                         call *__tls_get_addr@GOTPCREL(%rip
3547                         which may be converted to
3548                         addr32 call __tls_get_addr
3549                      into:
3550                         movq %fs:0, %rax
3551                         addq foo@gottpoff(%rip), %rax
3552                      For 32bit, change
3553                         leaq foo@tlsgd(%rip), %rdi
3554                         .word 0x6666; rex64; call __tls_get_addr@PLT
3555                      or
3556                         leaq foo@tlsgd(%rip), %rdi
3557                         .byte 0x66; rex64;
3558                         call *__tls_get_addr@GOTPCREL(%rip)
3559                         which may be converted to
3560                         addr32 call __tls_get_addr
3561                      into:
3562                         movl %fs:0, %eax
3563                         addq foo@gottpoff(%rip), %rax
3564                      For largepic, change:
3565                         leaq foo@tlsgd(%rip), %rdi
3566                         movabsq $__tls_get_addr@pltoff, %rax
3567                         addq %r15, %rax
3568                         call *%rax
3569                      into:
3570                         movq %fs:0, %rax
3571                         addq foo@gottpoff(%rax), %rax
3572                         nopw 0x0(%rax,%rax,1)  */
3573                   int largepic = 0;
3574                   if (ABI_64_P (output_bfd))
3575                     {
3576                       if (contents[roff + 5] == 0xb8)
3577                         {
3578                           memcpy (contents + roff - 3,
3579                                   "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
3580                                   "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3581                           largepic = 1;
3582                         }
3583                       else
3584                         memcpy (contents + roff - 4,
3585                                 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3586                                 16);
3587                     }
3588                   else
3589                     memcpy (contents + roff - 3,
3590                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3591                             15);
3592
3593                   relocation = (htab->elf.sgot->output_section->vma
3594                                 + htab->elf.sgot->output_offset + off
3595                                 - roff
3596                                 - largepic
3597                                 - input_section->output_section->vma
3598                                 - input_section->output_offset
3599                                 - 12);
3600                   bfd_put_32 (output_bfd, relocation,
3601                               contents + roff + 8 + largepic);
3602                   /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
3603                   rel++;
3604                   wrel++;
3605                   continue;
3606                 }
3607               else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3608                 {
3609                   /* GDesc -> IE transition.
3610                      It's originally something like:
3611                      leaq x@tlsdesc(%rip), %rax
3612
3613                      Change it to:
3614                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
3615
3616                   /* Now modify the instruction as appropriate. To
3617                      turn a leaq into a movq in the form we use it, it
3618                      suffices to change the second byte from 0x8d to
3619                      0x8b.  */
3620                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3621
3622                   bfd_put_32 (output_bfd,
3623                               htab->elf.sgot->output_section->vma
3624                               + htab->elf.sgot->output_offset + off
3625                               - rel->r_offset
3626                               - input_section->output_section->vma
3627                               - input_section->output_offset
3628                               - 4,
3629                               contents + roff);
3630                   continue;
3631                 }
3632               else if (r_type == R_X86_64_TLSDESC_CALL)
3633                 {
3634                   /* GDesc -> IE transition.
3635                      It's originally:
3636                      call *(%rax)
3637
3638                      Change it to:
3639                      xchg %ax, %ax.  */
3640
3641                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3642                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3643                   continue;
3644                 }
3645               else
3646                 BFD_ASSERT (FALSE);
3647             }
3648           break;
3649
3650         case R_X86_64_TLSLD:
3651           if (! elf_x86_64_tls_transition (info, input_bfd,
3652                                            input_section, contents,
3653                                            symtab_hdr, sym_hashes,
3654                                            &r_type, GOT_UNKNOWN, rel,
3655                                            relend, h, r_symndx, TRUE))
3656             return FALSE;
3657
3658           if (r_type != R_X86_64_TLSLD)
3659             {
3660               /* LD->LE transition:
3661                         leaq foo@tlsld(%rip), %rdi
3662                         call __tls_get_addr@PLT
3663                  For 64bit, we change it into:
3664                         .word 0x6666; .byte 0x66; movq %fs:0, %rax
3665                  For 32bit, we change it into:
3666                         nopl 0x0(%rax); movl %fs:0, %eax
3667                  Or
3668                         leaq foo@tlsld(%rip), %rdi;
3669                         call *__tls_get_addr@GOTPCREL(%rip)
3670                         which may be converted to
3671                         addr32 call __tls_get_addr
3672                  For 64bit, we change it into:
3673                         .word 0x6666; .word 0x6666; movq %fs:0, %rax
3674                  For 32bit, we change it into:
3675                         nopw 0x0(%rax); movl %fs:0, %eax
3676                  For largepic, change:
3677                         leaq foo@tlsgd(%rip), %rdi
3678                         movabsq $__tls_get_addr@pltoff, %rax
3679                         addq %rbx, %rax
3680                         call *%rax
3681                  into
3682                         data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
3683                         movq %fs:0, %eax  */
3684
3685               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3686               if (ABI_64_P (output_bfd))
3687                 {
3688                   if (contents[rel->r_offset + 5] == 0xb8)
3689                     memcpy (contents + rel->r_offset - 3,
3690                             "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
3691                             "\x64\x48\x8b\x04\x25\0\0\0", 22);
3692                   else if (contents[rel->r_offset + 4] == 0xff
3693                            || contents[rel->r_offset + 4] == 0x67)
3694                     memcpy (contents + rel->r_offset - 3,
3695                             "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
3696                             13);
3697                   else
3698                     memcpy (contents + rel->r_offset - 3,
3699                             "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3700                 }
3701               else
3702                 {
3703                   if (contents[rel->r_offset + 4] == 0xff)
3704                     memcpy (contents + rel->r_offset - 3,
3705                             "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
3706                             13);
3707                   else
3708                     memcpy (contents + rel->r_offset - 3,
3709                             "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
3710                 }
3711               /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
3712                  and R_X86_64_PLTOFF64.  */
3713               rel++;
3714               wrel++;
3715               continue;
3716             }
3717
3718           if (htab->elf.sgot == NULL)
3719             abort ();
3720
3721           off = htab->tls_ld_or_ldm_got.offset;
3722           if (off & 1)
3723             off &= ~1;
3724           else
3725             {
3726               Elf_Internal_Rela outrel;
3727
3728               if (htab->elf.srelgot == NULL)
3729                 abort ();
3730
3731               outrel.r_offset = (htab->elf.sgot->output_section->vma
3732                                  + htab->elf.sgot->output_offset + off);
3733
3734               bfd_put_64 (output_bfd, 0,
3735                           htab->elf.sgot->contents + off);
3736               bfd_put_64 (output_bfd, 0,
3737                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3738               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
3739               outrel.r_addend = 0;
3740               elf_append_rela (output_bfd, htab->elf.srelgot,
3741                                         &outrel);
3742               htab->tls_ld_or_ldm_got.offset |= 1;
3743             }
3744           relocation = htab->elf.sgot->output_section->vma
3745                        + htab->elf.sgot->output_offset + off;
3746           unresolved_reloc = FALSE;
3747           break;
3748
3749         case R_X86_64_DTPOFF32:
3750           if (!bfd_link_executable (info)
3751               || (input_section->flags & SEC_CODE) == 0)
3752             relocation -= _bfd_x86_elf_dtpoff_base (info);
3753           else
3754             relocation = elf_x86_64_tpoff (info, relocation);
3755           break;
3756
3757         case R_X86_64_TPOFF32:
3758         case R_X86_64_TPOFF64:
3759           BFD_ASSERT (bfd_link_executable (info));
3760           relocation = elf_x86_64_tpoff (info, relocation);
3761           break;
3762
3763         case R_X86_64_DTPOFF64:
3764           BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
3765           relocation -= _bfd_x86_elf_dtpoff_base (info);
3766           break;
3767
3768         default:
3769           break;
3770         }
3771
3772       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3773          because such sections are not SEC_ALLOC and thus ld.so will
3774          not process them.  */
3775       if (unresolved_reloc
3776           && !((input_section->flags & SEC_DEBUGGING) != 0
3777                && h->def_dynamic)
3778           && _bfd_elf_section_offset (output_bfd, info, input_section,
3779                                       rel->r_offset) != (bfd_vma) -1)
3780         {
3781           switch (r_type)
3782             {
3783             case R_X86_64_32S:
3784               sec = h->root.u.def.section;
3785               if ((info->nocopyreloc
3786                    || (eh->def_protected
3787                        && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3788                   && !(h->root.u.def.section->flags & SEC_CODE))
3789                 return elf_x86_64_need_pic (info, input_bfd, input_section,
3790                                             h, NULL, NULL, howto);
3791               /* Fall through.  */
3792
3793             default:
3794               _bfd_error_handler
3795                 /* xgettext:c-format */
3796                 (_("%pB(%pA+%#" PRIx64 "): "
3797                    "unresolvable %s relocation against symbol `%s'"),
3798                  input_bfd,
3799                  input_section,
3800                  (uint64_t) rel->r_offset,
3801                  howto->name,
3802                  h->root.root.string);
3803               return FALSE;
3804             }
3805         }
3806
3807 do_relocation:
3808       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3809                                     contents, rel->r_offset,
3810                                     relocation, rel->r_addend);
3811
3812 check_relocation_error:
3813       if (r != bfd_reloc_ok)
3814         {
3815           const char *name;
3816
3817           if (h != NULL)
3818             name = h->root.root.string;
3819           else
3820             {
3821               name = bfd_elf_string_from_elf_section (input_bfd,
3822                                                       symtab_hdr->sh_link,
3823                                                       sym->st_name);
3824               if (name == NULL)
3825                 return FALSE;
3826               if (*name == '\0')
3827                 name = bfd_section_name (input_bfd, sec);
3828             }
3829
3830           if (r == bfd_reloc_overflow)
3831             {
3832               if (converted_reloc)
3833                 {
3834                   info->callbacks->einfo
3835                     (_("%F%P: failed to convert GOTPCREL relocation; relink with --no-relax\n"));
3836                   return FALSE;
3837                 }
3838               (*info->callbacks->reloc_overflow)
3839                 (info, (h ? &h->root : NULL), name, howto->name,
3840                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3841             }
3842           else
3843             {
3844               _bfd_error_handler
3845                 /* xgettext:c-format */
3846                 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3847                  input_bfd, input_section,
3848                  (uint64_t) rel->r_offset, name, (int) r);
3849               return FALSE;
3850             }
3851         }
3852
3853       if (wrel != rel)
3854         *wrel = *rel;
3855     }
3856
3857   if (wrel != rel)
3858     {
3859       Elf_Internal_Shdr *rel_hdr;
3860       size_t deleted = rel - wrel;
3861
3862       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3863       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3864       if (rel_hdr->sh_size == 0)
3865         {
3866           /* It is too late to remove an empty reloc section.  Leave
3867              one NONE reloc.
3868              ??? What is wrong with an empty section???  */
3869           rel_hdr->sh_size = rel_hdr->sh_entsize;
3870           deleted -= 1;
3871         }
3872       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3873       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3874       input_section->reloc_count -= deleted;
3875     }
3876
3877   return TRUE;
3878 }
3879
3880 /* Finish up dynamic symbol handling.  We set the contents of various
3881    dynamic sections here.  */
3882
3883 static bfd_boolean
3884 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3885                                   struct bfd_link_info *info,
3886                                   struct elf_link_hash_entry *h,
3887                                   Elf_Internal_Sym *sym)
3888 {
3889   struct elf_x86_link_hash_table *htab;
3890   bfd_boolean use_plt_second;
3891   struct elf_x86_link_hash_entry *eh;
3892   bfd_boolean local_undefweak;
3893
3894   htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
3895   if (htab == NULL)
3896     return FALSE;
3897
3898   /* Use the second PLT section only if there is .plt section.  */
3899   use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3900
3901   eh = (struct elf_x86_link_hash_entry *) h;
3902   if (eh->no_finish_dynamic_symbol)
3903     abort ();
3904
3905   /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3906      resolved undefined weak symbols in executable so that their
3907      references have value 0 at run-time.  */
3908   local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3909
3910   if (h->plt.offset != (bfd_vma) -1)
3911     {
3912       bfd_vma plt_index;
3913       bfd_vma got_offset, plt_offset;
3914       Elf_Internal_Rela rela;
3915       bfd_byte *loc;
3916       asection *plt, *gotplt, *relplt, *resolved_plt;
3917       const struct elf_backend_data *bed;
3918       bfd_vma plt_got_pcrel_offset;
3919
3920       /* When building a static executable, use .iplt, .igot.plt and
3921          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
3922       if (htab->elf.splt != NULL)
3923         {
3924           plt = htab->elf.splt;
3925           gotplt = htab->elf.sgotplt;
3926           relplt = htab->elf.srelplt;
3927         }
3928       else
3929         {
3930           plt = htab->elf.iplt;
3931           gotplt = htab->elf.igotplt;
3932           relplt = htab->elf.irelplt;
3933         }
3934
3935       VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3936
3937       /* Get the index in the procedure linkage table which
3938          corresponds to this symbol.  This is the index of this symbol
3939          in all the symbols for which we are making plt entries.  The
3940          first entry in the procedure linkage table is reserved.
3941
3942          Get the offset into the .got table of the entry that
3943          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
3944          bytes. The first three are reserved for the dynamic linker.
3945
3946          For static executables, we don't reserve anything.  */
3947
3948       if (plt == htab->elf.splt)
3949         {
3950           got_offset = (h->plt.offset / htab->plt.plt_entry_size
3951                         - htab->plt.has_plt0);
3952           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
3953         }
3954       else
3955         {
3956           got_offset = h->plt.offset / htab->plt.plt_entry_size;
3957           got_offset = got_offset * GOT_ENTRY_SIZE;
3958         }
3959
3960       /* Fill in the entry in the procedure linkage table.  */
3961       memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3962               htab->plt.plt_entry_size);
3963       if (use_plt_second)
3964         {
3965           memcpy (htab->plt_second->contents + eh->plt_second.offset,
3966                   htab->non_lazy_plt->plt_entry,
3967                   htab->non_lazy_plt->plt_entry_size);
3968
3969           resolved_plt = htab->plt_second;
3970           plt_offset = eh->plt_second.offset;
3971         }
3972       else
3973         {
3974           resolved_plt = plt;
3975           plt_offset = h->plt.offset;
3976         }
3977
3978       /* Insert the relocation positions of the plt section.  */
3979
3980       /* Put offset the PC-relative instruction referring to the GOT entry,
3981          subtracting the size of that instruction.  */
3982       plt_got_pcrel_offset = (gotplt->output_section->vma
3983                               + gotplt->output_offset
3984                               + got_offset
3985                               - resolved_plt->output_section->vma
3986                               - resolved_plt->output_offset
3987                               - plt_offset
3988                               - htab->plt.plt_got_insn_size);
3989
3990       /* Check PC-relative offset overflow in PLT entry.  */
3991       if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
3992         /* xgettext:c-format */
3993         info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in PLT entry for `%s'\n"),
3994                                 output_bfd, h->root.root.string);
3995
3996       bfd_put_32 (output_bfd, plt_got_pcrel_offset,
3997                   (resolved_plt->contents + plt_offset
3998                    + htab->plt.plt_got_offset));
3999
4000       /* Fill in the entry in the global offset table, initially this
4001          points to the second part of the PLT entry.  Leave the entry
4002          as zero for undefined weak symbol in PIE.  No PLT relocation
4003          against undefined weak symbol in PIE.  */
4004       if (!local_undefweak)
4005         {
4006           if (htab->plt.has_plt0)
4007             bfd_put_64 (output_bfd, (plt->output_section->vma
4008                                      + plt->output_offset
4009                                      + h->plt.offset
4010                                      + htab->lazy_plt->plt_lazy_offset),
4011                         gotplt->contents + got_offset);
4012
4013           /* Fill in the entry in the .rela.plt section.  */
4014           rela.r_offset = (gotplt->output_section->vma
4015                            + gotplt->output_offset
4016                            + got_offset);
4017           if (PLT_LOCAL_IFUNC_P (info, h))
4018             {
4019               info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
4020                                       h->root.root.string,
4021                                       h->root.u.def.section->owner);
4022
4023               /* If an STT_GNU_IFUNC symbol is locally defined, generate
4024                  R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
4025               rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4026               rela.r_addend = (h->root.u.def.value
4027                                + h->root.u.def.section->output_section->vma
4028                                + h->root.u.def.section->output_offset);
4029               /* R_X86_64_IRELATIVE comes last.  */
4030               plt_index = htab->next_irelative_index--;
4031             }
4032           else
4033             {
4034               rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4035               rela.r_addend = 0;
4036               plt_index = htab->next_jump_slot_index++;
4037             }
4038
4039           /* Don't fill the second and third slots in PLT entry for
4040              static executables nor without PLT0.  */
4041           if (plt == htab->elf.splt && htab->plt.has_plt0)
4042             {
4043               bfd_vma plt0_offset
4044                 = h->plt.offset + htab->lazy_plt->plt_plt_insn_end;
4045
4046               /* Put relocation index.  */
4047               bfd_put_32 (output_bfd, plt_index,
4048                           (plt->contents + h->plt.offset
4049                            + htab->lazy_plt->plt_reloc_offset));
4050
4051               /* Put offset for jmp .PLT0 and check for overflow.  We don't
4052                  check relocation index for overflow since branch displacement
4053                  will overflow first.  */
4054               if (plt0_offset > 0x80000000)
4055                 /* xgettext:c-format */
4056                 info->callbacks->einfo (_("%F%pB: branch displacement overflow in PLT entry for `%s'\n"),
4057                                         output_bfd, h->root.root.string);
4058               bfd_put_32 (output_bfd, - plt0_offset,
4059                           (plt->contents + h->plt.offset
4060                            + htab->lazy_plt->plt_plt_offset));
4061             }
4062
4063           bed = get_elf_backend_data (output_bfd);
4064           loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4065           bed->s->swap_reloca_out (output_bfd, &rela, loc);
4066         }
4067     }
4068   else if (eh->plt_got.offset != (bfd_vma) -1)
4069     {
4070       bfd_vma got_offset, plt_offset;
4071       asection *plt, *got;
4072       bfd_boolean got_after_plt;
4073       int32_t got_pcrel_offset;
4074
4075       /* Set the entry in the GOT procedure linkage table.  */
4076       plt = htab->plt_got;
4077       got = htab->elf.sgot;
4078       got_offset = h->got.offset;
4079
4080       if (got_offset == (bfd_vma) -1
4081           || (h->type == STT_GNU_IFUNC && h->def_regular)
4082           || plt == NULL
4083           || got == NULL)
4084         abort ();
4085
4086       /* Use the non-lazy PLT entry template for the GOT PLT since they
4087          are the identical.  */
4088       /* Fill in the entry in the GOT procedure linkage table.  */
4089       plt_offset = eh->plt_got.offset;
4090       memcpy (plt->contents + plt_offset,
4091               htab->non_lazy_plt->plt_entry,
4092               htab->non_lazy_plt->plt_entry_size);
4093
4094       /* Put offset the PC-relative instruction referring to the GOT
4095          entry, subtracting the size of that instruction.  */
4096       got_pcrel_offset = (got->output_section->vma
4097                           + got->output_offset
4098                           + got_offset
4099                           - plt->output_section->vma
4100                           - plt->output_offset
4101                           - plt_offset
4102                           - htab->non_lazy_plt->plt_got_insn_size);
4103
4104       /* Check PC-relative offset overflow in GOT PLT entry.  */
4105       got_after_plt = got->output_section->vma > plt->output_section->vma;
4106       if ((got_after_plt && got_pcrel_offset < 0)
4107           || (!got_after_plt && got_pcrel_offset > 0))
4108         /* xgettext:c-format */
4109         info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
4110                                 output_bfd, h->root.root.string);
4111
4112       bfd_put_32 (output_bfd, got_pcrel_offset,
4113                   (plt->contents + plt_offset
4114                    + htab->non_lazy_plt->plt_got_offset));
4115     }
4116
4117   if (!local_undefweak
4118       && !h->def_regular
4119       && (h->plt.offset != (bfd_vma) -1
4120           || eh->plt_got.offset != (bfd_vma) -1))
4121     {
4122       /* Mark the symbol as undefined, rather than as defined in
4123          the .plt section.  Leave the value if there were any
4124          relocations where pointer equality matters (this is a clue
4125          for the dynamic linker, to make function pointer
4126          comparisons work between an application and shared
4127          library), otherwise set it to zero.  If a function is only
4128          called from a binary, there is no need to slow down
4129          shared libraries because of that.  */
4130       sym->st_shndx = SHN_UNDEF;
4131       if (!h->pointer_equality_needed)
4132         sym->st_value = 0;
4133     }
4134
4135   /* Don't generate dynamic GOT relocation against undefined weak
4136      symbol in executable.  */
4137   if (h->got.offset != (bfd_vma) -1
4138       && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h)->tls_type)
4139       && elf_x86_hash_entry (h)->tls_type != GOT_TLS_IE
4140       && !local_undefweak)
4141     {
4142       Elf_Internal_Rela rela;
4143       asection *relgot = htab->elf.srelgot;
4144
4145       /* This symbol has an entry in the global offset table.  Set it
4146          up.  */
4147       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4148         abort ();
4149
4150       rela.r_offset = (htab->elf.sgot->output_section->vma
4151                        + htab->elf.sgot->output_offset
4152                        + (h->got.offset &~ (bfd_vma) 1));
4153
4154       /* If this is a static link, or it is a -Bsymbolic link and the
4155          symbol is defined locally or was forced to be local because
4156          of a version file, we just want to emit a RELATIVE reloc.
4157          The entry in the global offset table will already have been
4158          initialized in the relocate_section function.  */
4159       if (h->def_regular
4160           && h->type == STT_GNU_IFUNC)
4161         {
4162           if (h->plt.offset == (bfd_vma) -1)
4163             {
4164               /* STT_GNU_IFUNC is referenced without PLT.  */
4165               if (htab->elf.splt == NULL)
4166                 {
4167                   /* use .rel[a].iplt section to store .got relocations
4168                      in static executable.  */
4169                   relgot = htab->elf.irelplt;
4170                 }
4171               if (SYMBOL_REFERENCES_LOCAL_P (info, h))
4172                 {
4173                   info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
4174                                           h->root.root.string,
4175                                           h->root.u.def.section->owner);
4176
4177                   rela.r_info = htab->r_info (0,
4178                                               R_X86_64_IRELATIVE);
4179                   rela.r_addend = (h->root.u.def.value
4180                                    + h->root.u.def.section->output_section->vma
4181                                    + h->root.u.def.section->output_offset);
4182                 }
4183               else
4184                 goto do_glob_dat;
4185             }
4186           else if (bfd_link_pic (info))
4187             {
4188               /* Generate R_X86_64_GLOB_DAT.  */
4189               goto do_glob_dat;
4190             }
4191           else
4192             {
4193               asection *plt;
4194               bfd_vma plt_offset;
4195
4196               if (!h->pointer_equality_needed)
4197                 abort ();
4198
4199               /* For non-shared object, we can't use .got.plt, which
4200                  contains the real function addres if we need pointer
4201                  equality.  We load the GOT entry with the PLT entry.  */
4202               if (htab->plt_second != NULL)
4203                 {
4204                   plt = htab->plt_second;
4205                   plt_offset = eh->plt_second.offset;
4206                 }
4207               else
4208                 {
4209                   plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4210                   plt_offset =  h->plt.offset;
4211                 }
4212               bfd_put_64 (output_bfd, (plt->output_section->vma
4213                                        + plt->output_offset
4214                                        + plt_offset),
4215                           htab->elf.sgot->contents + h->got.offset);
4216               return TRUE;
4217             }
4218         }
4219       else if (bfd_link_pic (info)
4220                && SYMBOL_REFERENCES_LOCAL_P (info, h))
4221         {
4222           if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
4223             return FALSE;
4224           BFD_ASSERT((h->got.offset & 1) != 0);
4225           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4226           rela.r_addend = (h->root.u.def.value
4227                            + h->root.u.def.section->output_section->vma
4228                            + h->root.u.def.section->output_offset);
4229         }
4230       else
4231         {
4232           BFD_ASSERT((h->got.offset & 1) == 0);
4233 do_glob_dat:
4234           bfd_put_64 (output_bfd, (bfd_vma) 0,
4235                       htab->elf.sgot->contents + h->got.offset);
4236           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4237           rela.r_addend = 0;
4238         }
4239
4240       elf_append_rela (output_bfd, relgot, &rela);
4241     }
4242
4243   if (h->needs_copy)
4244     {
4245       Elf_Internal_Rela rela;
4246       asection *s;
4247
4248       /* This symbol needs a copy reloc.  Set it up.  */
4249       VERIFY_COPY_RELOC (h, htab)
4250
4251       rela.r_offset = (h->root.u.def.value
4252                        + h->root.u.def.section->output_section->vma
4253                        + h->root.u.def.section->output_offset);
4254       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4255       rela.r_addend = 0;
4256       if (h->root.u.def.section == htab->elf.sdynrelro)
4257         s = htab->elf.sreldynrelro;
4258       else
4259         s = htab->elf.srelbss;
4260       elf_append_rela (output_bfd, s, &rela);
4261     }
4262
4263   return TRUE;
4264 }
4265
4266 /* Finish up local dynamic symbol handling.  We set the contents of
4267    various dynamic sections here.  */
4268
4269 static bfd_boolean
4270 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4271 {
4272   struct elf_link_hash_entry *h
4273     = (struct elf_link_hash_entry *) *slot;
4274   struct bfd_link_info *info
4275     = (struct bfd_link_info *) inf;
4276
4277   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4278                                            info, h, NULL);
4279 }
4280
4281 /* Finish up undefined weak symbol handling in PIE.  Fill its PLT entry
4282    here since undefined weak symbol may not be dynamic and may not be
4283    called for elf_x86_64_finish_dynamic_symbol.  */
4284
4285 static bfd_boolean
4286 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
4287                                         void *inf)
4288 {
4289   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
4290   struct bfd_link_info *info = (struct bfd_link_info *) inf;
4291
4292   if (h->root.type != bfd_link_hash_undefweak
4293       || h->dynindx != -1)
4294     return TRUE;
4295
4296   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4297                                            info, h, NULL);
4298 }
4299
4300 /* Used to decide how to sort relocs in an optimal manner for the
4301    dynamic linker, before writing them out.  */
4302
4303 static enum elf_reloc_type_class
4304 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
4305                              const asection *rel_sec ATTRIBUTE_UNUSED,
4306                              const Elf_Internal_Rela *rela)
4307 {
4308   bfd *abfd = info->output_bfd;
4309   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4310   struct elf_x86_link_hash_table *htab
4311     = elf_x86_hash_table (info, X86_64_ELF_DATA);
4312
4313   if (htab->elf.dynsym != NULL
4314       && htab->elf.dynsym->contents != NULL)
4315     {
4316       /* Check relocation against STT_GNU_IFUNC symbol if there are
4317          dynamic symbols.  */
4318       unsigned long r_symndx = htab->r_sym (rela->r_info);
4319       if (r_symndx != STN_UNDEF)
4320         {
4321           Elf_Internal_Sym sym;
4322           if (!bed->s->swap_symbol_in (abfd,
4323                                        (htab->elf.dynsym->contents
4324                                         + r_symndx * bed->s->sizeof_sym),
4325                                        0, &sym))
4326             abort ();
4327
4328           if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
4329             return reloc_class_ifunc;
4330         }
4331     }
4332
4333   switch ((int) ELF32_R_TYPE (rela->r_info))
4334     {
4335     case R_X86_64_IRELATIVE:
4336       return reloc_class_ifunc;
4337     case R_X86_64_RELATIVE:
4338     case R_X86_64_RELATIVE64:
4339       return reloc_class_relative;
4340     case R_X86_64_JUMP_SLOT:
4341       return reloc_class_plt;
4342     case R_X86_64_COPY:
4343       return reloc_class_copy;
4344     default:
4345       return reloc_class_normal;
4346     }
4347 }
4348
4349 /* Finish up the dynamic sections.  */
4350
4351 static bfd_boolean
4352 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4353                                     struct bfd_link_info *info)
4354 {
4355   struct elf_x86_link_hash_table *htab;
4356
4357   htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
4358   if (htab == NULL)
4359     return FALSE;
4360
4361   if (! htab->elf.dynamic_sections_created)
4362     return TRUE;
4363
4364   if (htab->elf.splt && htab->elf.splt->size > 0)
4365     {
4366       elf_section_data (htab->elf.splt->output_section)
4367         ->this_hdr.sh_entsize = htab->plt.plt_entry_size;
4368
4369       if (htab->plt.has_plt0)
4370         {
4371           /* Fill in the special first entry in the procedure linkage
4372              table.  */
4373           memcpy (htab->elf.splt->contents,
4374                   htab->lazy_plt->plt0_entry,
4375                   htab->lazy_plt->plt0_entry_size);
4376           /* Add offset for pushq GOT+8(%rip), since the instruction
4377              uses 6 bytes subtract this value.  */
4378           bfd_put_32 (output_bfd,
4379                       (htab->elf.sgotplt->output_section->vma
4380                        + htab->elf.sgotplt->output_offset
4381                        + 8
4382                        - htab->elf.splt->output_section->vma
4383                        - htab->elf.splt->output_offset
4384                        - 6),
4385                       (htab->elf.splt->contents
4386                        + htab->lazy_plt->plt0_got1_offset));
4387           /* Add offset for the PC-relative instruction accessing
4388              GOT+16, subtracting the offset to the end of that
4389              instruction.  */
4390           bfd_put_32 (output_bfd,
4391                       (htab->elf.sgotplt->output_section->vma
4392                        + htab->elf.sgotplt->output_offset
4393                        + 16
4394                        - htab->elf.splt->output_section->vma
4395                        - htab->elf.splt->output_offset
4396                        - htab->lazy_plt->plt0_got2_insn_end),
4397                       (htab->elf.splt->contents
4398                        + htab->lazy_plt->plt0_got2_offset));
4399         }
4400
4401       if (htab->tlsdesc_plt)
4402         {
4403           bfd_put_64 (output_bfd, (bfd_vma) 0,
4404                       htab->elf.sgot->contents + htab->tlsdesc_got);
4405
4406           memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4407                   htab->lazy_plt->plt0_entry,
4408                   htab->lazy_plt->plt0_entry_size);
4409
4410           /* Add offset for pushq GOT+8(%rip), since the
4411              instruction uses 6 bytes subtract this value.  */
4412           bfd_put_32 (output_bfd,
4413                       (htab->elf.sgotplt->output_section->vma
4414                        + htab->elf.sgotplt->output_offset
4415                        + 8
4416                        - htab->elf.splt->output_section->vma
4417                        - htab->elf.splt->output_offset
4418                        - htab->tlsdesc_plt
4419                        - 6),
4420                       (htab->elf.splt->contents
4421                        + htab->tlsdesc_plt
4422                        + htab->lazy_plt->plt0_got1_offset));
4423           /* Add offset for the PC-relative instruction accessing
4424              GOT+TDG, where TDG stands for htab->tlsdesc_got,
4425              subtracting the offset to the end of that
4426              instruction.  */
4427           bfd_put_32 (output_bfd,
4428                       (htab->elf.sgot->output_section->vma
4429                        + htab->elf.sgot->output_offset
4430                        + htab->tlsdesc_got
4431                        - htab->elf.splt->output_section->vma
4432                        - htab->elf.splt->output_offset
4433                        - htab->tlsdesc_plt
4434                        - htab->lazy_plt->plt0_got2_insn_end),
4435                       (htab->elf.splt->contents
4436                        + htab->tlsdesc_plt
4437                        + htab->lazy_plt->plt0_got2_offset));
4438         }
4439     }
4440
4441   /* Fill PLT entries for undefined weak symbols in PIE.  */
4442   if (bfd_link_pie (info))
4443     bfd_hash_traverse (&info->hash->table,
4444                        elf_x86_64_pie_finish_undefweak_symbol,
4445                        info);
4446
4447   return TRUE;
4448 }
4449
4450 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4451    STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4452    It has to be done before elf_link_sort_relocs is called so that
4453    dynamic relocations are properly sorted.  */
4454
4455 static bfd_boolean
4456 elf_x86_64_output_arch_local_syms
4457   (bfd *output_bfd ATTRIBUTE_UNUSED,
4458    struct bfd_link_info *info,
4459    void *flaginfo ATTRIBUTE_UNUSED,
4460    int (*func) (void *, const char *,
4461                 Elf_Internal_Sym *,
4462                 asection *,
4463                 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4464 {
4465   struct elf_x86_link_hash_table *htab
4466     = elf_x86_hash_table (info, X86_64_ELF_DATA);
4467   if (htab == NULL)
4468     return FALSE;
4469
4470   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4471   htab_traverse (htab->loc_hash_table,
4472                  elf_x86_64_finish_local_dynamic_symbol,
4473                  info);
4474
4475   return TRUE;
4476 }
4477
4478 /* Forward declaration.  */
4479 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt;
4480
4481 /* Similar to _bfd_elf_get_synthetic_symtab.  Support PLTs with all
4482    dynamic relocations.   */
4483
4484 static long
4485 elf_x86_64_get_synthetic_symtab (bfd *abfd,
4486                                  long symcount ATTRIBUTE_UNUSED,
4487                                  asymbol **syms ATTRIBUTE_UNUSED,
4488                                  long dynsymcount,
4489                                  asymbol **dynsyms,
4490                                  asymbol **ret)
4491 {
4492   long count, i, n;
4493   int j;
4494   bfd_byte *plt_contents;
4495   long relsize;
4496   const struct elf_x86_lazy_plt_layout *lazy_plt;
4497   const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4498   const struct elf_x86_lazy_plt_layout *lazy_bnd_plt;
4499   const struct elf_x86_non_lazy_plt_layout *non_lazy_bnd_plt;
4500   const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4501   const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4502   asection *plt;
4503   enum elf_x86_plt_type plt_type;
4504   struct elf_x86_plt plts[] =
4505     {
4506       { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4507       { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4508       { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4509       { ".plt.bnd", NULL, NULL, plt_second, 0, 0, 0, 0 },
4510       { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4511     };
4512
4513   *ret = NULL;
4514
4515   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4516     return 0;
4517
4518   if (dynsymcount <= 0)
4519     return 0;
4520
4521   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4522   if (relsize <= 0)
4523     return -1;
4524
4525   if (get_elf_x86_backend_data (abfd)->target_os != is_nacl)
4526     {
4527       lazy_plt = &elf_x86_64_lazy_plt;
4528       non_lazy_plt = &elf_x86_64_non_lazy_plt;
4529       lazy_bnd_plt = &elf_x86_64_lazy_bnd_plt;
4530       non_lazy_bnd_plt = &elf_x86_64_non_lazy_bnd_plt;
4531       if (ABI_64_P (abfd))
4532         {
4533           lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4534           non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4535         }
4536       else
4537         {
4538           lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4539           non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4540         }
4541     }
4542   else
4543     {
4544       lazy_plt = &elf_x86_64_nacl_plt;
4545       non_lazy_plt = NULL;
4546       lazy_bnd_plt = NULL;
4547       non_lazy_bnd_plt = NULL;
4548       lazy_ibt_plt = NULL;
4549       non_lazy_ibt_plt = NULL;
4550     }
4551
4552   count = 0;
4553   for (j = 0; plts[j].name != NULL; j++)
4554     {
4555       plt = bfd_get_section_by_name (abfd, plts[j].name);
4556       if (plt == NULL || plt->size == 0)
4557         continue;
4558
4559       /* Get the PLT section contents.  */
4560       plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4561       if (plt_contents == NULL)
4562         break;
4563       if (!bfd_get_section_contents (abfd, (asection *) plt,
4564                                      plt_contents, 0, plt->size))
4565         {
4566           free (plt_contents);
4567           break;
4568         }
4569
4570       /* Check what kind of PLT it is.  */
4571       plt_type = plt_unknown;
4572       if (plts[j].type == plt_unknown
4573           && (plt->size >= (lazy_plt->plt_entry_size
4574                             + lazy_plt->plt_entry_size)))
4575         {
4576           /* Match lazy PLT first.  Need to check the first two
4577              instructions.   */
4578           if ((memcmp (plt_contents, lazy_plt->plt0_entry,
4579                        lazy_plt->plt0_got1_offset) == 0)
4580               && (memcmp (plt_contents + 6, lazy_plt->plt0_entry + 6,
4581                           2) == 0))
4582             plt_type = plt_lazy;
4583           else if (lazy_bnd_plt != NULL
4584                    && (memcmp (plt_contents, lazy_bnd_plt->plt0_entry,
4585                                lazy_bnd_plt->plt0_got1_offset) == 0)
4586                    && (memcmp (plt_contents + 6,
4587                                lazy_bnd_plt->plt0_entry + 6, 3) == 0))
4588             {
4589               plt_type = plt_lazy | plt_second;
4590               /* The fist entry in the lazy IBT PLT is the same as the
4591                  lazy BND PLT.  */
4592               if ((memcmp (plt_contents + lazy_ibt_plt->plt_entry_size,
4593                            lazy_ibt_plt->plt_entry,
4594                            lazy_ibt_plt->plt_got_offset) == 0))
4595                 lazy_plt = lazy_ibt_plt;
4596               else
4597                 lazy_plt = lazy_bnd_plt;
4598             }
4599         }
4600
4601       if (non_lazy_plt != NULL
4602           && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4603           && plt->size >= non_lazy_plt->plt_entry_size)
4604         {
4605           /* Match non-lazy PLT.  */
4606           if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4607                       non_lazy_plt->plt_got_offset) == 0)
4608             plt_type = plt_non_lazy;
4609         }
4610
4611       if (plt_type == plt_unknown || plt_type == plt_second)
4612         {
4613           if (non_lazy_bnd_plt != NULL
4614               && plt->size >= non_lazy_bnd_plt->plt_entry_size
4615               && (memcmp (plt_contents, non_lazy_bnd_plt->plt_entry,
4616                           non_lazy_bnd_plt->plt_got_offset) == 0))
4617             {
4618               /* Match BND PLT.  */
4619               plt_type = plt_second;
4620               non_lazy_plt = non_lazy_bnd_plt;
4621             }
4622           else if (non_lazy_ibt_plt != NULL
4623                    && plt->size >= non_lazy_ibt_plt->plt_entry_size
4624                    && (memcmp (plt_contents,
4625                                non_lazy_ibt_plt->plt_entry,
4626                                non_lazy_ibt_plt->plt_got_offset) == 0))
4627             {
4628               /* Match IBT PLT.  */
4629               plt_type = plt_second;
4630               non_lazy_plt = non_lazy_ibt_plt;
4631             }
4632         }
4633
4634       if (plt_type == plt_unknown)
4635         {
4636           free (plt_contents);
4637           continue;
4638         }
4639
4640       plts[j].sec = plt;
4641       plts[j].type = plt_type;
4642
4643       if ((plt_type & plt_lazy))
4644         {
4645           plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4646           plts[j].plt_got_insn_size = lazy_plt->plt_got_insn_size;
4647           plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4648           /* Skip PLT0 in lazy PLT.  */
4649           i = 1;
4650         }
4651       else
4652         {
4653           plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4654           plts[j].plt_got_insn_size = non_lazy_plt->plt_got_insn_size;
4655           plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4656           i = 0;
4657         }
4658
4659       /* Skip lazy PLT when the second PLT is used.  */
4660       if (plt_type == (plt_lazy | plt_second))
4661         plts[j].count = 0;
4662       else
4663         {
4664           n = plt->size / plts[j].plt_entry_size;
4665           plts[j].count = n;
4666           count += n - i;
4667         }
4668
4669       plts[j].contents = plt_contents;
4670     }
4671
4672   return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4673                                             (bfd_vma) 0, plts, dynsyms,
4674                                             ret);
4675 }
4676
4677 /* Handle an x86-64 specific section when reading an object file.  This
4678    is called when elfcode.h finds a section with an unknown type.  */
4679
4680 static bfd_boolean
4681 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
4682                               const char *name, int shindex)
4683 {
4684   if (hdr->sh_type != SHT_X86_64_UNWIND)
4685     return FALSE;
4686
4687   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4688     return FALSE;
4689
4690   return TRUE;
4691 }
4692
4693 /* Hook called by the linker routine which adds symbols from an object
4694    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4695    of .bss.  */
4696
4697 static bfd_boolean
4698 elf_x86_64_add_symbol_hook (bfd *abfd,
4699                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
4700                             Elf_Internal_Sym *sym,
4701                             const char **namep ATTRIBUTE_UNUSED,
4702                             flagword *flagsp ATTRIBUTE_UNUSED,
4703                             asection **secp,
4704                             bfd_vma *valp)
4705 {
4706   asection *lcomm;
4707
4708   switch (sym->st_shndx)
4709     {
4710     case SHN_X86_64_LCOMMON:
4711       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4712       if (lcomm == NULL)
4713         {
4714           lcomm = bfd_make_section_with_flags (abfd,
4715                                                "LARGE_COMMON",
4716                                                (SEC_ALLOC
4717                                                 | SEC_IS_COMMON
4718                                                 | SEC_LINKER_CREATED));
4719           if (lcomm == NULL)
4720             return FALSE;
4721           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4722         }
4723       *secp = lcomm;
4724       *valp = sym->st_size;
4725       return TRUE;
4726     }
4727
4728   return TRUE;
4729 }
4730
4731
4732 /* Given a BFD section, try to locate the corresponding ELF section
4733    index.  */
4734
4735 static bfd_boolean
4736 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4737                                          asection *sec, int *index_return)
4738 {
4739   if (sec == &_bfd_elf_large_com_section)
4740     {
4741       *index_return = SHN_X86_64_LCOMMON;
4742       return TRUE;
4743     }
4744   return FALSE;
4745 }
4746
4747 /* Process a symbol.  */
4748
4749 static void
4750 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4751                               asymbol *asym)
4752 {
4753   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4754
4755   switch (elfsym->internal_elf_sym.st_shndx)
4756     {
4757     case SHN_X86_64_LCOMMON:
4758       asym->section = &_bfd_elf_large_com_section;
4759       asym->value = elfsym->internal_elf_sym.st_size;
4760       /* Common symbol doesn't set BSF_GLOBAL.  */
4761       asym->flags &= ~BSF_GLOBAL;
4762       break;
4763     }
4764 }
4765
4766 static bfd_boolean
4767 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4768 {
4769   return (sym->st_shndx == SHN_COMMON
4770           || sym->st_shndx == SHN_X86_64_LCOMMON);
4771 }
4772
4773 static unsigned int
4774 elf_x86_64_common_section_index (asection *sec)
4775 {
4776   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4777     return SHN_COMMON;
4778   else
4779     return SHN_X86_64_LCOMMON;
4780 }
4781
4782 static asection *
4783 elf_x86_64_common_section (asection *sec)
4784 {
4785   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4786     return bfd_com_section_ptr;
4787   else
4788     return &_bfd_elf_large_com_section;
4789 }
4790
4791 static bfd_boolean
4792 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
4793                          const Elf_Internal_Sym *sym,
4794                          asection **psec,
4795                          bfd_boolean newdef,
4796                          bfd_boolean olddef,
4797                          bfd *oldbfd,
4798                          const asection *oldsec)
4799 {
4800   /* A normal common symbol and a large common symbol result in a
4801      normal common symbol.  We turn the large common symbol into a
4802      normal one.  */
4803   if (!olddef
4804       && h->root.type == bfd_link_hash_common
4805       && !newdef
4806       && bfd_is_com_section (*psec)
4807       && oldsec != *psec)
4808     {
4809       if (sym->st_shndx == SHN_COMMON
4810           && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
4811         {
4812           h->root.u.c.p->section
4813             = bfd_make_section_old_way (oldbfd, "COMMON");
4814           h->root.u.c.p->section->flags = SEC_ALLOC;
4815         }
4816       else if (sym->st_shndx == SHN_X86_64_LCOMMON
4817                && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
4818         *psec = bfd_com_section_ptr;
4819     }
4820
4821   return TRUE;
4822 }
4823
4824 static int
4825 elf_x86_64_additional_program_headers (bfd *abfd,
4826                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
4827 {
4828   asection *s;
4829   int count = 0;
4830
4831   /* Check to see if we need a large readonly segment.  */
4832   s = bfd_get_section_by_name (abfd, ".lrodata");
4833   if (s && (s->flags & SEC_LOAD))
4834     count++;
4835
4836   /* Check to see if we need a large data segment.  Since .lbss sections
4837      is placed right after the .bss section, there should be no need for
4838      a large data segment just because of .lbss.  */
4839   s = bfd_get_section_by_name (abfd, ".ldata");
4840   if (s && (s->flags & SEC_LOAD))
4841     count++;
4842
4843   return count;
4844 }
4845
4846 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4847
4848 static bfd_boolean
4849 elf_x86_64_relocs_compatible (const bfd_target *input,
4850                               const bfd_target *output)
4851 {
4852   return ((xvec_get_elf_backend_data (input)->s->elfclass
4853            == xvec_get_elf_backend_data (output)->s->elfclass)
4854           && _bfd_elf_relocs_compatible (input, output));
4855 }
4856
4857 /* Set up x86-64 GNU properties.  Return the first relocatable ELF input
4858    with GNU properties if found.  Otherwise, return NULL.  */
4859
4860 static bfd *
4861 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
4862 {
4863   struct elf_x86_init_table init_table;
4864
4865   if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit
4866       || (int) R_X86_64_max <= (int) R_X86_64_converted_reloc_bit
4867       || ((int) (R_X86_64_GNU_VTINHERIT | R_X86_64_converted_reloc_bit)
4868           != (int) R_X86_64_GNU_VTINHERIT)
4869       || ((int) (R_X86_64_GNU_VTENTRY | R_X86_64_converted_reloc_bit)
4870           != (int) R_X86_64_GNU_VTENTRY))
4871     abort ();
4872
4873   /* This is unused for x86-64.  */
4874   init_table.plt0_pad_byte = 0x90;
4875
4876   if (get_elf_x86_backend_data (info->output_bfd)->target_os != is_nacl)
4877     {
4878       if (info->bndplt)
4879         {
4880           init_table.lazy_plt = &elf_x86_64_lazy_bnd_plt;
4881           init_table.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt;
4882         }
4883       else
4884         {
4885           init_table.lazy_plt = &elf_x86_64_lazy_plt;
4886           init_table.non_lazy_plt = &elf_x86_64_non_lazy_plt;
4887         }
4888
4889       if (ABI_64_P (info->output_bfd))
4890         {
4891           init_table.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4892           init_table.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4893         }
4894       else
4895         {
4896           init_table.lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4897           init_table.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4898         }
4899     }
4900   else
4901     {
4902       init_table.lazy_plt = &elf_x86_64_nacl_plt;
4903       init_table.non_lazy_plt = NULL;
4904       init_table.lazy_ibt_plt = NULL;
4905       init_table.non_lazy_ibt_plt = NULL;
4906     }
4907
4908   if (ABI_64_P (info->output_bfd))
4909     {
4910       init_table.r_info = elf64_r_info;
4911       init_table.r_sym = elf64_r_sym;
4912     }
4913   else
4914     {
4915       init_table.r_info = elf32_r_info;
4916       init_table.r_sym = elf32_r_sym;
4917     }
4918
4919   return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4920 }
4921
4922 static const struct bfd_elf_special_section
4923 elf_x86_64_special_sections[]=
4924 {
4925   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4926   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4927   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4928   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4929   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4930   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4931   { NULL,                       0,          0, 0,            0 }
4932 };
4933
4934 #define TARGET_LITTLE_SYM                   x86_64_elf64_vec
4935 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
4936 #define ELF_ARCH                            bfd_arch_i386
4937 #define ELF_TARGET_ID                       X86_64_ELF_DATA
4938 #define ELF_MACHINE_CODE                    EM_X86_64
4939 #define ELF_MAXPAGESIZE                     0x200000
4940 #define ELF_MINPAGESIZE                     0x1000
4941 #define ELF_COMMONPAGESIZE                  0x1000
4942
4943 #define elf_backend_can_gc_sections         1
4944 #define elf_backend_can_refcount            1
4945 #define elf_backend_want_got_plt            1
4946 #define elf_backend_plt_readonly            1
4947 #define elf_backend_want_plt_sym            0
4948 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
4949 #define elf_backend_rela_normal             1
4950 #define elf_backend_plt_alignment           4
4951 #define elf_backend_extern_protected_data   1
4952 #define elf_backend_caches_rawsize          1
4953 #define elf_backend_dtrel_excludes_plt      1
4954 #define elf_backend_want_dynrelro           1
4955
4956 #define elf_info_to_howto                   elf_x86_64_info_to_howto
4957
4958 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
4959 #define bfd_elf64_bfd_reloc_name_lookup \
4960   elf_x86_64_reloc_name_lookup
4961
4962 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
4963 #define elf_backend_check_relocs            elf_x86_64_check_relocs
4964 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
4965 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4966 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
4967 #define elf_backend_output_arch_local_syms  elf_x86_64_output_arch_local_syms
4968 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
4969 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
4970 #ifdef CORE_HEADER
4971 #define elf_backend_write_core_note         elf_x86_64_write_core_note
4972 #endif
4973 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
4974 #define elf_backend_relocate_section        elf_x86_64_relocate_section
4975 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
4976 #define elf_backend_object_p                elf64_x86_64_elf_object_p
4977 #define bfd_elf64_get_synthetic_symtab      elf_x86_64_get_synthetic_symtab
4978
4979 #define elf_backend_section_from_shdr \
4980         elf_x86_64_section_from_shdr
4981
4982 #define elf_backend_section_from_bfd_section \
4983   elf_x86_64_elf_section_from_bfd_section
4984 #define elf_backend_add_symbol_hook \
4985   elf_x86_64_add_symbol_hook
4986 #define elf_backend_symbol_processing \
4987   elf_x86_64_symbol_processing
4988 #define elf_backend_common_section_index \
4989   elf_x86_64_common_section_index
4990 #define elf_backend_common_section \
4991   elf_x86_64_common_section
4992 #define elf_backend_common_definition \
4993   elf_x86_64_common_definition
4994 #define elf_backend_merge_symbol \
4995   elf_x86_64_merge_symbol
4996 #define elf_backend_special_sections \
4997   elf_x86_64_special_sections
4998 #define elf_backend_additional_program_headers \
4999   elf_x86_64_additional_program_headers
5000 #define elf_backend_setup_gnu_properties \
5001   elf_x86_64_link_setup_gnu_properties
5002 #define elf_backend_hide_symbol \
5003   _bfd_x86_elf_hide_symbol
5004
5005 #include "elf64-target.h"
5006
5007 /* CloudABI support.  */
5008
5009 #undef  TARGET_LITTLE_SYM
5010 #define TARGET_LITTLE_SYM                   x86_64_elf64_cloudabi_vec
5011 #undef  TARGET_LITTLE_NAME
5012 #define TARGET_LITTLE_NAME                  "elf64-x86-64-cloudabi"
5013
5014 #undef  ELF_OSABI
5015 #define ELF_OSABI                           ELFOSABI_CLOUDABI
5016
5017 #undef  elf64_bed
5018 #define elf64_bed elf64_x86_64_cloudabi_bed
5019
5020 #include "elf64-target.h"
5021
5022 /* FreeBSD support.  */
5023
5024 #undef  TARGET_LITTLE_SYM
5025 #define TARGET_LITTLE_SYM                   x86_64_elf64_fbsd_vec
5026 #undef  TARGET_LITTLE_NAME
5027 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
5028
5029 #undef  ELF_OSABI
5030 #define ELF_OSABI                           ELFOSABI_FREEBSD
5031
5032 #undef  elf64_bed
5033 #define elf64_bed elf64_x86_64_fbsd_bed
5034
5035 #include "elf64-target.h"
5036
5037 /* Solaris 2 support.  */
5038
5039 #undef  TARGET_LITTLE_SYM
5040 #define TARGET_LITTLE_SYM                   x86_64_elf64_sol2_vec
5041 #undef  TARGET_LITTLE_NAME
5042 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
5043
5044 static const struct elf_x86_backend_data elf_x86_64_solaris_arch_bed =
5045   {
5046     is_solaris                              /* os */
5047   };
5048
5049 #undef  elf_backend_arch_data
5050 #define elf_backend_arch_data               &elf_x86_64_solaris_arch_bed
5051
5052 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5053    objects won't be recognized.  */
5054 #undef ELF_OSABI
5055
5056 #undef  elf64_bed
5057 #define elf64_bed                           elf64_x86_64_sol2_bed
5058
5059 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5060    boundary.  */
5061 #undef  elf_backend_static_tls_alignment
5062 #define elf_backend_static_tls_alignment    16
5063
5064 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5065
5066    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5067    File, p.63.  */
5068 #undef  elf_backend_want_plt_sym
5069 #define elf_backend_want_plt_sym            1
5070
5071 #undef  elf_backend_strtab_flags
5072 #define elf_backend_strtab_flags        SHF_STRINGS
5073
5074 static bfd_boolean
5075 elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5076                                                   bfd *obfd ATTRIBUTE_UNUSED,
5077                                                   const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5078                                                   Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5079 {
5080   /* PR 19938: FIXME: Need to add code for setting the sh_info
5081      and sh_link fields of Solaris specific section types.  */
5082   return FALSE;
5083 }
5084
5085 #undef  elf_backend_copy_special_section_fields
5086 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
5087
5088 #include "elf64-target.h"
5089
5090 /* Native Client support.  */
5091
5092 static bfd_boolean
5093 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5094 {
5095   /* Set the right machine number for a NaCl x86-64 ELF64 file.  */
5096   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5097   return TRUE;
5098 }
5099
5100 #undef  TARGET_LITTLE_SYM
5101 #define TARGET_LITTLE_SYM               x86_64_elf64_nacl_vec
5102 #undef  TARGET_LITTLE_NAME
5103 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
5104 #undef  elf64_bed
5105 #define elf64_bed                       elf64_x86_64_nacl_bed
5106
5107 #undef  ELF_MAXPAGESIZE
5108 #undef  ELF_MINPAGESIZE
5109 #undef  ELF_COMMONPAGESIZE
5110 #define ELF_MAXPAGESIZE                 0x10000
5111 #define ELF_MINPAGESIZE                 0x10000
5112 #define ELF_COMMONPAGESIZE              0x10000
5113
5114 /* Restore defaults.  */
5115 #undef  ELF_OSABI
5116 #undef  elf_backend_static_tls_alignment
5117 #undef  elf_backend_want_plt_sym
5118 #define elf_backend_want_plt_sym        0
5119 #undef  elf_backend_strtab_flags
5120 #undef  elf_backend_copy_special_section_fields
5121
5122 /* NaCl uses substantially different PLT entries for the same effects.  */
5123
5124 #undef  elf_backend_plt_alignment
5125 #define elf_backend_plt_alignment       5
5126 #define NACL_PLT_ENTRY_SIZE             64
5127 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5128
5129 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5130   {
5131     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
5132     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
5133     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5134     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5135     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5136
5137     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
5138     0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1)     */
5139
5140     /* 32 bytes of nop to pad out to the standard size.  */
5141     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
5142     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5143     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
5144     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5145     0x66,                                  /* excess data16 prefix      */
5146     0x90                                   /* nop */
5147   };
5148
5149 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5150   {
5151     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
5152     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5153     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5154     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5155
5156     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
5157     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
5158     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5159
5160     /* Lazy GOT entries point here (32-byte aligned).  */
5161     0x68,                 /* pushq immediate */
5162     0, 0, 0, 0,           /* replaced with index into relocation table.  */
5163     0xe9,                 /* jmp relative */
5164     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
5165
5166     /* 22 bytes of nop to pad out to the standard size.  */
5167     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
5168     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5169     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
5170   };
5171
5172 /* .eh_frame covering the .plt section.  */
5173
5174 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5175   {
5176 #if (PLT_CIE_LENGTH != 20                               \
5177      || PLT_FDE_LENGTH != 36                            \
5178      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5179      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5180 # error "Need elf_x86_backend_data parameters for eh_frame_plt offsets!"
5181 #endif
5182     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
5183     0, 0, 0, 0,                 /* CIE ID */
5184     1,                          /* CIE version */
5185     'z', 'R', 0,                /* Augmentation string */
5186     1,                          /* Code alignment factor */
5187     0x78,                       /* Data alignment factor */
5188     16,                         /* Return address column */
5189     1,                          /* Augmentation size */
5190     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5191     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5192     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
5193     DW_CFA_nop, DW_CFA_nop,
5194
5195     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
5196     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5197     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
5198     0, 0, 0, 0,                 /* .plt size goes here */
5199     0,                          /* Augmentation size */
5200     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
5201     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5202     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
5203     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5204     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
5205     13,                         /* Block length */
5206     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
5207     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
5208     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5209     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5210     DW_CFA_nop, DW_CFA_nop
5211   };
5212
5213 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt =
5214   {
5215     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
5216     NACL_PLT_ENTRY_SIZE,                     /* plt0_entry_size */
5217     elf_x86_64_nacl_plt_entry,               /* plt_entry */
5218     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
5219     2,                                       /* plt0_got1_offset */
5220     9,                                       /* plt0_got2_offset */
5221     13,                                      /* plt0_got2_insn_end */
5222     3,                                       /* plt_got_offset */
5223     33,                                      /* plt_reloc_offset */
5224     38,                                      /* plt_plt_offset */
5225     7,                                       /* plt_got_insn_size */
5226     42,                                      /* plt_plt_insn_end */
5227     32,                                      /* plt_lazy_offset */
5228     elf_x86_64_nacl_plt0_entry,              /* pic_plt0_entry */
5229     elf_x86_64_nacl_plt_entry,               /* pic_plt_entry */
5230     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
5231     sizeof (elf_x86_64_nacl_eh_frame_plt)    /* eh_frame_plt_size */
5232   };
5233
5234 static const struct elf_x86_backend_data elf_x86_64_nacl_arch_bed =
5235   {
5236     is_nacl                                  /* os */
5237   };
5238
5239 #undef  elf_backend_arch_data
5240 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
5241
5242 #undef  elf_backend_object_p
5243 #define elf_backend_object_p                    elf64_x86_64_nacl_elf_object_p
5244 #undef  elf_backend_modify_segment_map
5245 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5246 #undef  elf_backend_modify_program_headers
5247 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5248 #undef  elf_backend_final_write_processing
5249 #define elf_backend_final_write_processing      nacl_final_write_processing
5250
5251 #include "elf64-target.h"
5252
5253 /* Native Client x32 support.  */
5254
5255 static bfd_boolean
5256 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5257 {
5258   /* Set the right machine number for a NaCl x86-64 ELF32 file.  */
5259   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5260   return TRUE;
5261 }
5262
5263 #undef  TARGET_LITTLE_SYM
5264 #define TARGET_LITTLE_SYM               x86_64_elf32_nacl_vec
5265 #undef  TARGET_LITTLE_NAME
5266 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
5267 #undef  elf32_bed
5268 #define elf32_bed                       elf32_x86_64_nacl_bed
5269
5270 #define bfd_elf32_bfd_reloc_type_lookup \
5271   elf_x86_64_reloc_type_lookup
5272 #define bfd_elf32_bfd_reloc_name_lookup \
5273   elf_x86_64_reloc_name_lookup
5274 #define bfd_elf32_get_synthetic_symtab \
5275   elf_x86_64_get_synthetic_symtab
5276
5277 #undef elf_backend_object_p
5278 #define elf_backend_object_p \
5279   elf32_x86_64_nacl_elf_object_p
5280
5281 #undef elf_backend_bfd_from_remote_memory
5282 #define elf_backend_bfd_from_remote_memory \
5283   _bfd_elf32_bfd_from_remote_memory
5284
5285 #undef elf_backend_size_info
5286 #define elf_backend_size_info \
5287   _bfd_elf32_size_info
5288
5289 #include "elf32-target.h"
5290
5291 /* Restore defaults.  */
5292 #undef  elf_backend_object_p
5293 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5294 #undef  elf_backend_bfd_from_remote_memory
5295 #undef  elf_backend_size_info
5296 #undef  elf_backend_modify_segment_map
5297 #undef  elf_backend_modify_program_headers
5298 #undef  elf_backend_final_write_processing
5299
5300 /* Intel L1OM support.  */
5301
5302 static bfd_boolean
5303 elf64_l1om_elf_object_p (bfd *abfd)
5304 {
5305   /* Set the right machine number for an L1OM elf64 file.  */
5306   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5307   return TRUE;
5308 }
5309
5310 #undef  TARGET_LITTLE_SYM
5311 #define TARGET_LITTLE_SYM                   l1om_elf64_vec
5312 #undef  TARGET_LITTLE_NAME
5313 #define TARGET_LITTLE_NAME                  "elf64-l1om"
5314 #undef ELF_ARCH
5315 #define ELF_ARCH                            bfd_arch_l1om
5316
5317 #undef  ELF_MACHINE_CODE
5318 #define ELF_MACHINE_CODE                    EM_L1OM
5319
5320 #undef  ELF_OSABI
5321
5322 #undef  elf64_bed
5323 #define elf64_bed elf64_l1om_bed
5324
5325 #undef elf_backend_object_p
5326 #define elf_backend_object_p                elf64_l1om_elf_object_p
5327
5328 /* Restore defaults.  */
5329 #undef  ELF_MAXPAGESIZE
5330 #undef  ELF_MINPAGESIZE
5331 #undef  ELF_COMMONPAGESIZE
5332 #define ELF_MAXPAGESIZE                 0x200000
5333 #define ELF_MINPAGESIZE                 0x1000
5334 #define ELF_COMMONPAGESIZE              0x1000
5335 #undef  elf_backend_plt_alignment
5336 #define elf_backend_plt_alignment       4
5337 #undef  elf_backend_arch_data
5338 #define elf_backend_arch_data   &elf_x86_64_arch_bed
5339
5340 #include "elf64-target.h"
5341
5342 /* FreeBSD L1OM support.  */
5343
5344 #undef  TARGET_LITTLE_SYM
5345 #define TARGET_LITTLE_SYM                   l1om_elf64_fbsd_vec
5346 #undef  TARGET_LITTLE_NAME
5347 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
5348
5349 #undef  ELF_OSABI
5350 #define ELF_OSABI                           ELFOSABI_FREEBSD
5351
5352 #undef  elf64_bed
5353 #define elf64_bed elf64_l1om_fbsd_bed
5354
5355 #include "elf64-target.h"
5356
5357 /* Intel K1OM support.  */
5358
5359 static bfd_boolean
5360 elf64_k1om_elf_object_p (bfd *abfd)
5361 {
5362   /* Set the right machine number for an K1OM elf64 file.  */
5363   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5364   return TRUE;
5365 }
5366
5367 #undef  TARGET_LITTLE_SYM
5368 #define TARGET_LITTLE_SYM                   k1om_elf64_vec
5369 #undef  TARGET_LITTLE_NAME
5370 #define TARGET_LITTLE_NAME                  "elf64-k1om"
5371 #undef ELF_ARCH
5372 #define ELF_ARCH                            bfd_arch_k1om
5373
5374 #undef  ELF_MACHINE_CODE
5375 #define ELF_MACHINE_CODE                    EM_K1OM
5376
5377 #undef  ELF_OSABI
5378
5379 #undef  elf64_bed
5380 #define elf64_bed elf64_k1om_bed
5381
5382 #undef elf_backend_object_p
5383 #define elf_backend_object_p                elf64_k1om_elf_object_p
5384
5385 #undef  elf_backend_static_tls_alignment
5386
5387 #undef elf_backend_want_plt_sym
5388 #define elf_backend_want_plt_sym            0
5389
5390 #include "elf64-target.h"
5391
5392 /* FreeBSD K1OM support.  */
5393
5394 #undef  TARGET_LITTLE_SYM
5395 #define TARGET_LITTLE_SYM                   k1om_elf64_fbsd_vec
5396 #undef  TARGET_LITTLE_NAME
5397 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
5398
5399 #undef  ELF_OSABI
5400 #define ELF_OSABI                           ELFOSABI_FREEBSD
5401
5402 #undef  elf64_bed
5403 #define elf64_bed elf64_k1om_fbsd_bed
5404
5405 #include "elf64-target.h"
5406
5407 /* 32bit x86-64 support.  */
5408
5409 #undef  TARGET_LITTLE_SYM
5410 #define TARGET_LITTLE_SYM                   x86_64_elf32_vec
5411 #undef  TARGET_LITTLE_NAME
5412 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
5413 #undef  elf32_bed
5414
5415 #undef ELF_ARCH
5416 #define ELF_ARCH                            bfd_arch_i386
5417
5418 #undef  ELF_MACHINE_CODE
5419 #define ELF_MACHINE_CODE                    EM_X86_64
5420
5421 #undef  ELF_OSABI
5422
5423 #undef elf_backend_object_p
5424 #define elf_backend_object_p \
5425   elf32_x86_64_elf_object_p
5426
5427 #undef elf_backend_bfd_from_remote_memory
5428 #define elf_backend_bfd_from_remote_memory \
5429   _bfd_elf32_bfd_from_remote_memory
5430
5431 #undef elf_backend_size_info
5432 #define elf_backend_size_info \
5433   _bfd_elf32_size_info
5434
5435 #include "elf32-target.h"