bfd/elf64-x86-64.c

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