bfd/elf64-x86-64.c

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