bfd/elf64-x86-64.c

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