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