bfd/elf64-x86-64.c

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