bfd/elf64-x86-64.c

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