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