bfd/elf64-x86-64.c

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