bfd/elf64-x86-64.c

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