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 <jh@suse.cz>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "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           eh->plt_got.offset = (bfd_vma) -1;
2727           h->plt.offset = (bfd_vma) -1;
2728           h->needs_plt = 0;
2729         }
2730     }
2731   else
2732     {
2733       eh->plt_got.offset = (bfd_vma) -1;
2734       h->plt.offset = (bfd_vma) -1;
2735       h->needs_plt = 0;
2736     }
2737
2738   eh->tlsdesc_got = (bfd_vma) -1;
2739
2740   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2741      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
2742   if (h->got.refcount > 0
2743       && bfd_link_executable (info)
2744       && h->dynindx == -1
2745       && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2746     {
2747       h->got.offset = (bfd_vma) -1;
2748     }
2749   else if (h->got.refcount > 0)
2750     {
2751       asection *s;
2752       bfd_boolean dyn;
2753       int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2754
2755       /* Make sure this symbol is output as a dynamic symbol.
2756          Undefined weak syms won't yet be marked as dynamic.  */
2757       if (h->dynindx == -1
2758           && !h->forced_local)
2759         {
2760           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2761             return FALSE;
2762         }
2763
2764       if (GOT_TLS_GDESC_P (tls_type))
2765         {
2766           eh->tlsdesc_got = htab->elf.sgotplt->size
2767             - elf_x86_64_compute_jump_table_size (htab);
2768           htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2769           h->got.offset = (bfd_vma) -2;
2770         }
2771       if (! GOT_TLS_GDESC_P (tls_type)
2772           || GOT_TLS_GD_P (tls_type))
2773         {
2774           s = htab->elf.sgot;
2775           h->got.offset = s->size;
2776           s->size += GOT_ENTRY_SIZE;
2777           if (GOT_TLS_GD_P (tls_type))
2778             s->size += GOT_ENTRY_SIZE;
2779         }
2780       dyn = htab->elf.dynamic_sections_created;
2781       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2782          and two if global.
2783          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
2784       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2785           || tls_type == GOT_TLS_IE)
2786         htab->elf.srelgot->size += bed->s->sizeof_rela;
2787       else if (GOT_TLS_GD_P (tls_type))
2788         htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2789       else if (! GOT_TLS_GDESC_P (tls_type)
2790                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2791                    || h->root.type != bfd_link_hash_undefweak)
2792                && (bfd_link_pic (info)
2793                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2794         htab->elf.srelgot->size += bed->s->sizeof_rela;
2795       if (GOT_TLS_GDESC_P (tls_type))
2796         {
2797           htab->elf.srelplt->size += bed->s->sizeof_rela;
2798           htab->tlsdesc_plt = (bfd_vma) -1;
2799         }
2800     }
2801   else
2802     h->got.offset = (bfd_vma) -1;
2803
2804   if (eh->dyn_relocs == NULL)
2805     return TRUE;
2806
2807   /* In the shared -Bsymbolic case, discard space allocated for
2808      dynamic pc-relative relocs against symbols which turn out to be
2809      defined in regular objects.  For the normal shared case, discard
2810      space for pc-relative relocs that have become local due to symbol
2811      visibility changes.  */
2812
2813   if (bfd_link_pic (info))
2814     {
2815       /* Relocs that use pc_count are those that appear on a call
2816          insn, or certain REL relocs that can generated via assembly.
2817          We want calls to protected symbols to resolve directly to the
2818          function rather than going via the plt.  If people want
2819          function pointer comparisons to work as expected then they
2820          should avoid writing weird assembly.  */
2821       if (SYMBOL_CALLS_LOCAL (info, h))
2822         {
2823           struct elf_dyn_relocs **pp;
2824
2825           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2826             {
2827               p->count -= p->pc_count;
2828               p->pc_count = 0;
2829               if (p->count == 0)
2830                 *pp = p->next;
2831               else
2832                 pp = &p->next;
2833             }
2834         }
2835
2836       /* Also discard relocs on undefined weak syms with non-default
2837          visibility.  */
2838       if (eh->dyn_relocs != NULL)
2839         {
2840           if (h->root.type == bfd_link_hash_undefweak)
2841             {
2842               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2843                 eh->dyn_relocs = NULL;
2844
2845               /* Make sure undefined weak symbols are output as a dynamic
2846                  symbol in PIEs.  */
2847               else if (h->dynindx == -1
2848                        && ! h->forced_local
2849                        && ! bfd_elf_link_record_dynamic_symbol (info, h))
2850                 return FALSE;
2851             }
2852           /* For PIE, discard space for pc-relative relocs against
2853              symbols which turn out to need copy relocs.  */
2854           else if (bfd_link_executable (info)
2855                    && (h->needs_copy || eh->needs_copy)
2856                    && h->def_dynamic
2857                    && !h->def_regular)
2858             {
2859               struct elf_dyn_relocs **pp;
2860
2861               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2862                 {
2863                   if (p->pc_count != 0)
2864                     *pp = p->next;
2865                   else
2866                     pp = &p->next;
2867                 }
2868             }
2869         }
2870     }
2871   else if (ELIMINATE_COPY_RELOCS)
2872     {
2873       /* For the non-shared case, discard space for relocs against
2874          symbols which turn out to need copy relocs or are not
2875          dynamic.  Keep dynamic relocations for run-time function
2876          pointer initialization.  */
2877
2878       if ((!h->non_got_ref || eh->func_pointer_refcount > 0)
2879           && ((h->def_dynamic
2880                && !h->def_regular)
2881               || (htab->elf.dynamic_sections_created
2882                   && (h->root.type == bfd_link_hash_undefweak
2883                       || h->root.type == bfd_link_hash_undefined))))
2884         {
2885           /* Make sure this symbol is output as a dynamic symbol.
2886              Undefined weak syms won't yet be marked as dynamic.  */
2887           if (h->dynindx == -1
2888               && ! h->forced_local
2889               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2890             return FALSE;
2891
2892           /* If that succeeded, we know we'll be keeping all the
2893              relocs.  */
2894           if (h->dynindx != -1)
2895             goto keep;
2896         }
2897
2898       eh->dyn_relocs = NULL;
2899       eh->func_pointer_refcount = 0;
2900
2901     keep: ;
2902     }
2903
2904   /* Finally, allocate space.  */
2905   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2906     {
2907       asection * sreloc;
2908
2909       sreloc = elf_section_data (p->sec)->sreloc;
2910
2911       BFD_ASSERT (sreloc != NULL);
2912
2913       sreloc->size += p->count * bed->s->sizeof_rela;
2914     }
2915
2916   return TRUE;
2917 }
2918
2919 /* Allocate space in .plt, .got and associated reloc sections for
2920    local dynamic relocs.  */
2921
2922 static bfd_boolean
2923 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2924 {
2925   struct elf_link_hash_entry *h
2926     = (struct elf_link_hash_entry *) *slot;
2927
2928   if (h->type != STT_GNU_IFUNC
2929       || !h->def_regular
2930       || !h->ref_regular
2931       || !h->forced_local
2932       || h->root.type != bfd_link_hash_defined)
2933     abort ();
2934
2935   return elf_x86_64_allocate_dynrelocs (h, inf);
2936 }
2937
2938 /* Find any dynamic relocs that apply to read-only sections.  */
2939
2940 static bfd_boolean
2941 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2942                                void * inf)
2943 {
2944   struct elf_x86_64_link_hash_entry *eh;
2945   struct elf_dyn_relocs *p;
2946
2947   /* Skip local IFUNC symbols. */
2948   if (h->forced_local && h->type == STT_GNU_IFUNC)
2949     return TRUE;
2950
2951   eh = (struct elf_x86_64_link_hash_entry *) h;
2952   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2953     {
2954       asection *s = p->sec->output_section;
2955
2956       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2957         {
2958           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2959
2960           info->flags |= DF_TEXTREL;
2961
2962           if ((info->warn_shared_textrel && bfd_link_pic (info))
2963               || info->error_textrel)
2964             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2965                                     p->sec->owner, h->root.root.string,
2966                                     p->sec);
2967
2968           /* Not an error, just cut short the traversal.  */
2969           return FALSE;
2970         }
2971     }
2972   return TRUE;
2973 }
2974
2975 /* With the local symbol, foo, we convert
2976    mov foo@GOTPCREL(%rip), %reg
2977    to
2978    lea foo(%rip), %reg
2979    and convert
2980    call/jmp *foo@GOTPCREL(%rip)
2981    to
2982    nop call foo/jmp foo nop
2983    When PIC is false, convert
2984    test %reg, foo@GOTPCREL(%rip)
2985    to
2986    test $foo, %reg
2987    and convert
2988    binop foo@GOTPCREL(%rip), %reg
2989    to
2990    binop $foo, %reg
2991    where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2992    instructions.  */
2993
2994 static bfd_boolean
2995 elf_x86_64_convert_load (bfd *abfd, asection *sec,
2996                          struct bfd_link_info *link_info)
2997 {
2998   Elf_Internal_Shdr *symtab_hdr;
2999   Elf_Internal_Rela *internal_relocs;
3000   Elf_Internal_Rela *irel, *irelend;
3001   bfd_byte *contents;
3002   struct elf_x86_64_link_hash_table *htab;
3003   bfd_boolean changed_contents;
3004   bfd_boolean changed_relocs;
3005   bfd_signed_vma *local_got_refcounts;
3006   bfd_vma maxpagesize;
3007
3008   /* Don't even try to convert non-ELF outputs.  */
3009   if (!is_elf_hash_table (link_info->hash))
3010     return FALSE;
3011
3012   /* Nothing to do if there is no need or no output.  */
3013   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
3014       || sec->need_convert_load == 0
3015       || bfd_is_abs_section (sec->output_section))
3016     return TRUE;
3017
3018   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3019
3020   /* Load the relocations for this section.  */
3021   internal_relocs = (_bfd_elf_link_read_relocs
3022                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3023                       link_info->keep_memory));
3024   if (internal_relocs == NULL)
3025     return FALSE;
3026
3027   htab = elf_x86_64_hash_table (link_info);
3028   changed_contents = FALSE;
3029   changed_relocs = FALSE;
3030   local_got_refcounts = elf_local_got_refcounts (abfd);
3031   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3032
3033   /* Get the section contents.  */
3034   if (elf_section_data (sec)->this_hdr.contents != NULL)
3035     contents = elf_section_data (sec)->this_hdr.contents;
3036   else
3037     {
3038       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3039         goto error_return;
3040     }
3041
3042   irelend = internal_relocs + sec->reloc_count;
3043   for (irel = internal_relocs; irel < irelend; irel++)
3044     {
3045       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3046       unsigned int r_symndx = htab->r_sym (irel->r_info);
3047       unsigned int indx;
3048       struct elf_link_hash_entry *h;
3049       asection *tsec;
3050       char symtype;
3051       bfd_vma toff, roff;
3052       bfd_signed_vma raddend;
3053       unsigned int opcode;
3054       unsigned int modrm;
3055
3056       if (r_type != R_X86_64_GOTPCREL
3057           && r_type != R_X86_64_GOTPCRELX
3058           && r_type != R_X86_64_REX_GOTPCRELX)
3059         continue;
3060
3061       roff = irel->r_offset;
3062       if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
3063         continue;
3064
3065       raddend = irel->r_addend;
3066       /* Addend for 32-bit PC-relative relocation must be -4.  */
3067       if (raddend != -4)
3068         continue;
3069
3070       opcode = bfd_get_8 (abfd, contents + roff - 2);
3071
3072       /* It is OK to convert mov to lea.  */
3073       if (opcode != 0x8b)
3074         {
3075           /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3076              for mov call, jmp or one of adc, add, and, cmp, or, sbb,
3077              sub, test, xor instructions.  */
3078           if (r_type != R_X86_64_GOTPCRELX
3079               && r_type != R_X86_64_REX_GOTPCRELX)
3080             continue;
3081
3082           /* It is OK to convert indirect branch to direct branch.  */
3083           if (opcode != 0xff)
3084             {
3085               /* It is OK to convert adc, add, and, cmp, or, sbb, sub,
3086                  test, xor only when PIC is false.   */
3087               if (bfd_link_pic (link_info))
3088                 continue;
3089             }
3090         }
3091
3092       /* Get the symbol referred to by the reloc.  */
3093       if (r_symndx < symtab_hdr->sh_info)
3094         {
3095           Elf_Internal_Sym *isym;
3096
3097           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3098                                         abfd, r_symndx);
3099
3100           symtype = ELF_ST_TYPE (isym->st_info);
3101
3102           /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3103              relocation against undefined symbols.  */
3104           if (symtype == STT_GNU_IFUNC || isym->st_shndx == SHN_UNDEF)
3105             continue;
3106
3107           if (isym->st_shndx == SHN_ABS)
3108             tsec = bfd_abs_section_ptr;
3109           else if (isym->st_shndx == SHN_COMMON)
3110             tsec = bfd_com_section_ptr;
3111           else if (isym->st_shndx == SHN_X86_64_LCOMMON)
3112             tsec = &_bfd_elf_large_com_section;
3113           else
3114             tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3115
3116           h = NULL;
3117           toff = isym->st_value;
3118         }
3119       else
3120         {
3121           indx = r_symndx - symtab_hdr->sh_info;
3122           h = elf_sym_hashes (abfd)[indx];
3123           BFD_ASSERT (h != NULL);
3124
3125           while (h->root.type == bfd_link_hash_indirect
3126                  || h->root.type == bfd_link_hash_warning)
3127             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3128
3129           /* STT_GNU_IFUNC must keep GOTPCREL relocations.  We also
3130              avoid optimizing GOTPCREL relocations againt _DYNAMIC
3131              since ld.so may use its link-time address.  */
3132           if ((h->def_regular
3133                || h->root.type == bfd_link_hash_defined
3134                || h->root.type == bfd_link_hash_defweak)
3135               && h->type != STT_GNU_IFUNC
3136               && h != htab->elf.hdynamic
3137               && SYMBOL_REFERENCES_LOCAL (link_info, h))
3138             {
3139               /* bfd_link_hash_new or bfd_link_hash_undefined is
3140                  set by an assignment in a linker script in
3141                  bfd_elf_record_link_assignment.  FIXME: If we
3142                  ever get a linker error due relocation overflow,
3143                  we will skip this optimization.  */
3144               if (h->def_regular
3145                   && (h->root.type == bfd_link_hash_new
3146                       || h->root.type == bfd_link_hash_undefined))
3147                 goto convert;
3148               tsec = h->root.u.def.section;
3149               toff = h->root.u.def.value;
3150               symtype = h->type;
3151             }
3152           else
3153             continue;
3154         }
3155
3156       if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
3157         {
3158           /* At this stage in linking, no SEC_MERGE symbol has been
3159              adjusted, so all references to such symbols need to be
3160              passed through _bfd_merged_section_offset.  (Later, in
3161              relocate_section, all SEC_MERGE symbols *except* for
3162              section symbols have been adjusted.)
3163
3164              gas may reduce relocations against symbols in SEC_MERGE
3165              sections to a relocation against the section symbol when
3166              the original addend was zero.  When the reloc is against
3167              a section symbol we should include the addend in the
3168              offset passed to _bfd_merged_section_offset, since the
3169              location of interest is the original symbol.  On the
3170              other hand, an access to "sym+addend" where "sym" is not
3171              a section symbol should not include the addend;  Such an
3172              access is presumed to be an offset from "sym";  The
3173              location of interest is just "sym".  */
3174            if (symtype == STT_SECTION)
3175              toff += raddend;
3176
3177            toff = _bfd_merged_section_offset (abfd, &tsec,
3178                                               elf_section_data (tsec)->sec_info,
3179                                               toff);
3180
3181            if (symtype != STT_SECTION)
3182              toff += raddend;
3183         }
3184       else
3185         toff += raddend;
3186
3187       /* Don't convert if R_X86_64_PC32 relocation overflows.  */
3188       if (tsec->output_section == sec->output_section)
3189         {
3190           if ((toff - roff + 0x80000000) > 0xffffffff)
3191             continue;
3192         }
3193       else
3194         {
3195           bfd_signed_vma distance;
3196
3197           /* At this point, we don't know the load addresses of TSEC
3198              section nor SEC section.  We estimate the distrance between
3199              SEC and TSEC.  We store the estimated distances in the
3200              compressed_size field of the output section, which is only
3201              used to decompress the compressed input section.  */
3202           if (sec->output_section->compressed_size == 0)
3203             {
3204               asection *asect;
3205               bfd_size_type size = 0;
3206               for (asect = link_info->output_bfd->sections;
3207                    asect != NULL;
3208                    asect = asect->next)
3209                 {
3210                   asection *i;
3211                   for (i = asect->map_head.s;
3212                        i != NULL;
3213                        i = i->map_head.s)
3214                     {
3215                       size = align_power (size, i->alignment_power);
3216                       size += i->size;
3217                     }
3218                   asect->compressed_size = size;
3219                 }
3220             }
3221
3222           /* Don't convert GOTPCREL relocations if TSEC isn't placed
3223              after SEC.  */
3224           distance = (tsec->output_section->compressed_size
3225                       - sec->output_section->compressed_size);
3226           if (distance < 0)
3227             continue;
3228
3229           /* Take PT_GNU_RELRO segment into account by adding
3230              maxpagesize.  */
3231           if ((toff + distance + maxpagesize - roff + 0x80000000)
3232               > 0xffffffff)
3233             continue;
3234         }
3235
3236 convert:
3237       if (opcode == 0xff)
3238         {
3239           /* We have "call/jmp *foo@GOTPCREL(%rip)".  */
3240           unsigned int nop;
3241           unsigned int disp;
3242           bfd_vma nop_offset;
3243
3244           /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3245              R_X86_64_PC32.  */
3246           modrm = bfd_get_8 (abfd, contents + roff - 1);
3247           if (modrm == 0x25)
3248             {
3249               /* Convert to "jmp foo nop".  */
3250               modrm = 0xe9;
3251               nop = NOP_OPCODE;
3252               nop_offset = irel->r_offset + 3;
3253               disp = bfd_get_32 (abfd, contents + irel->r_offset);
3254               irel->r_offset -= 1;
3255               bfd_put_32 (abfd, disp, contents + irel->r_offset);
3256             }
3257           else
3258             {
3259               /* Convert to "nop call foo".  ADDR_PREFIX_OPCODE
3260                  is a nop prefix.  */
3261               modrm = 0xe8;
3262               nop = link_info->call_nop_byte;
3263               if (link_info->call_nop_as_suffix)
3264                 {
3265                   nop_offset = irel->r_offset + 3;
3266                   disp = bfd_get_32 (abfd, contents + irel->r_offset);
3267                   irel->r_offset -= 1;
3268                   bfd_put_32 (abfd, disp, contents + irel->r_offset);
3269                 }
3270               else
3271                 nop_offset = irel->r_offset - 2;
3272             }
3273           bfd_put_8 (abfd, nop, contents + nop_offset);
3274           bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
3275           r_type = R_X86_64_PC32;
3276         }
3277       else
3278         {
3279           if (opcode == 0x8b)
3280             {
3281               /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3282                  "lea foo(%rip), %reg".  */
3283               opcode = 0x8d;
3284               r_type = R_X86_64_PC32;
3285             }
3286           else
3287             {
3288               modrm = bfd_get_8 (abfd, contents + roff - 1);
3289               if (opcode == 0x85)
3290                 {
3291                   /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3292                      "test $foo, %reg".  */
3293                   modrm = 0xc0 | (modrm & 0x38) >> 3;
3294                   opcode = 0xf7;
3295                 }
3296               else
3297                 {
3298                   /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3299                      "binop $foo, %reg".  */
3300                   modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
3301                   opcode = 0x81;
3302                 }
3303               bfd_put_8 (abfd, modrm, contents + roff - 1);
3304
3305               if (r_type == R_X86_64_REX_GOTPCRELX)
3306                 {
3307                   /* Move the R bit to the B bit in REX byte.  */
3308                   unsigned int rex = bfd_get_8 (abfd, contents + roff - 3);
3309                   rex = (rex & ~REX_R) | (rex & REX_R) >> 2;
3310                   bfd_put_8 (abfd, rex, contents + roff - 3);
3311                 }
3312               /* No addend for R_X86_64_32S relocation.  */
3313               irel->r_addend = 0;
3314               r_type = R_X86_64_32S;
3315             }
3316
3317           bfd_put_8 (abfd, opcode, contents + roff - 2);
3318         }
3319
3320       irel->r_info = htab->r_info (r_symndx, r_type);
3321       changed_contents = TRUE;
3322       changed_relocs = TRUE;
3323
3324       if (h)
3325         {
3326           if (h->got.refcount > 0)
3327             h->got.refcount -= 1;
3328         }
3329       else
3330         {
3331           if (local_got_refcounts != NULL
3332               && local_got_refcounts[r_symndx] > 0)
3333             local_got_refcounts[r_symndx] -= 1;
3334         }
3335     }
3336
3337   if (contents != NULL
3338       && elf_section_data (sec)->this_hdr.contents != contents)
3339     {
3340       if (!changed_contents && !link_info->keep_memory)
3341         free (contents);
3342       else
3343         {
3344           /* Cache the section contents for elf_link_input_bfd.  */
3345           elf_section_data (sec)->this_hdr.contents = contents;
3346         }
3347     }
3348
3349   if (elf_section_data (sec)->relocs != internal_relocs)
3350     {
3351       if (!changed_relocs)
3352         free (internal_relocs);
3353       else
3354         elf_section_data (sec)->relocs = internal_relocs;
3355     }
3356
3357   return TRUE;
3358
3359  error_return:
3360   if (contents != NULL
3361       && elf_section_data (sec)->this_hdr.contents != contents)
3362     free (contents);
3363   if (internal_relocs != NULL
3364       && elf_section_data (sec)->relocs != internal_relocs)
3365     free (internal_relocs);
3366   return FALSE;
3367 }
3368
3369 /* Set the sizes of the dynamic sections.  */
3370
3371 static bfd_boolean
3372 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
3373                                   struct bfd_link_info *info)
3374 {
3375   struct elf_x86_64_link_hash_table *htab;
3376   bfd *dynobj;
3377   asection *s;
3378   bfd_boolean relocs;
3379   bfd *ibfd;
3380   const struct elf_backend_data *bed;
3381
3382   htab = elf_x86_64_hash_table (info);
3383   if (htab == NULL)
3384     return FALSE;
3385   bed = get_elf_backend_data (output_bfd);
3386
3387   dynobj = htab->elf.dynobj;
3388   if (dynobj == NULL)
3389     abort ();
3390
3391   if (htab->elf.dynamic_sections_created)
3392     {
3393       /* Set the contents of the .interp section to the interpreter.  */
3394       if (bfd_link_executable (info) && !info->nointerp)
3395         {
3396           s = bfd_get_linker_section (dynobj, ".interp");
3397           if (s == NULL)
3398             abort ();
3399           s->size = htab->dynamic_interpreter_size;
3400           s->contents = (unsigned char *) htab->dynamic_interpreter;
3401         }
3402     }
3403
3404   /* Set up .got offsets for local syms, and space for local dynamic
3405      relocs.  */
3406   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3407     {
3408       bfd_signed_vma *local_got;
3409       bfd_signed_vma *end_local_got;
3410       char *local_tls_type;
3411       bfd_vma *local_tlsdesc_gotent;
3412       bfd_size_type locsymcount;
3413       Elf_Internal_Shdr *symtab_hdr;
3414       asection *srel;
3415
3416       if (! is_x86_64_elf (ibfd))
3417         continue;
3418
3419       for (s = ibfd->sections; s != NULL; s = s->next)
3420         {
3421           struct elf_dyn_relocs *p;
3422
3423           if (!elf_x86_64_convert_load (ibfd, s, info))
3424             return FALSE;
3425
3426           for (p = (struct elf_dyn_relocs *)
3427                     (elf_section_data (s)->local_dynrel);
3428                p != NULL;
3429                p = p->next)
3430             {
3431               if (!bfd_is_abs_section (p->sec)
3432                   && bfd_is_abs_section (p->sec->output_section))
3433                 {
3434                   /* Input section has been discarded, either because
3435                      it is a copy of a linkonce section or due to
3436                      linker script /DISCARD/, so we'll be discarding
3437                      the relocs too.  */
3438                 }
3439               else if (p->count != 0)
3440                 {
3441                   srel = elf_section_data (p->sec)->sreloc;
3442                   srel->size += p->count * bed->s->sizeof_rela;
3443                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
3444                       && (info->flags & DF_TEXTREL) == 0)
3445                     {
3446                       info->flags |= DF_TEXTREL;
3447                       if ((info->warn_shared_textrel && bfd_link_pic (info))
3448                           || info->error_textrel)
3449                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3450                                                 p->sec->owner, p->sec);
3451                     }
3452                 }
3453             }
3454         }
3455
3456       local_got = elf_local_got_refcounts (ibfd);
3457       if (!local_got)
3458         continue;
3459
3460       symtab_hdr = &elf_symtab_hdr (ibfd);
3461       locsymcount = symtab_hdr->sh_info;
3462       end_local_got = local_got + locsymcount;
3463       local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3464       local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3465       s = htab->elf.sgot;
3466       srel = htab->elf.srelgot;
3467       for (; local_got < end_local_got;
3468            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3469         {
3470           *local_tlsdesc_gotent = (bfd_vma) -1;
3471           if (*local_got > 0)
3472             {
3473               if (GOT_TLS_GDESC_P (*local_tls_type))
3474                 {
3475                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
3476                     - elf_x86_64_compute_jump_table_size (htab);
3477                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3478                   *local_got = (bfd_vma) -2;
3479                 }
3480               if (! GOT_TLS_GDESC_P (*local_tls_type)
3481                   || GOT_TLS_GD_P (*local_tls_type))
3482                 {
3483                   *local_got = s->size;
3484                   s->size += GOT_ENTRY_SIZE;
3485                   if (GOT_TLS_GD_P (*local_tls_type))
3486                     s->size += GOT_ENTRY_SIZE;
3487                 }
3488               if (bfd_link_pic (info)
3489                   || GOT_TLS_GD_ANY_P (*local_tls_type)
3490                   || *local_tls_type == GOT_TLS_IE)
3491                 {
3492                   if (GOT_TLS_GDESC_P (*local_tls_type))
3493                     {
3494                       htab->elf.srelplt->size
3495                         += bed->s->sizeof_rela;
3496                       htab->tlsdesc_plt = (bfd_vma) -1;
3497                     }
3498                   if (! GOT_TLS_GDESC_P (*local_tls_type)
3499                       || GOT_TLS_GD_P (*local_tls_type))
3500                     srel->size += bed->s->sizeof_rela;
3501                 }
3502             }
3503           else
3504             *local_got = (bfd_vma) -1;
3505         }
3506     }
3507
3508   if (htab->tls_ld_got.refcount > 0)
3509     {
3510       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3511          relocs.  */
3512       htab->tls_ld_got.offset = htab->elf.sgot->size;
3513       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3514       htab->elf.srelgot->size += bed->s->sizeof_rela;
3515     }
3516   else
3517     htab->tls_ld_got.offset = -1;
3518
3519   /* Allocate global sym .plt and .got entries, and space for global
3520      sym dynamic relocs.  */
3521   elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3522                           info);
3523
3524   /* Allocate .plt and .got entries, and space for local symbols.  */
3525   htab_traverse (htab->loc_hash_table,
3526                  elf_x86_64_allocate_local_dynrelocs,
3527                  info);
3528
3529   /* For every jump slot reserved in the sgotplt, reloc_count is
3530      incremented.  However, when we reserve space for TLS descriptors,
3531      it's not incremented, so in order to compute the space reserved
3532      for them, it suffices to multiply the reloc count by the jump
3533      slot size.
3534
3535      PR ld/13302: We start next_irelative_index at the end of .rela.plt
3536      so that R_X86_64_IRELATIVE entries come last.  */
3537   if (htab->elf.srelplt)
3538     {
3539       htab->sgotplt_jump_table_size
3540         = elf_x86_64_compute_jump_table_size (htab);
3541       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3542     }
3543   else if (htab->elf.irelplt)
3544     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3545
3546   if (htab->tlsdesc_plt)
3547     {
3548       /* If we're not using lazy TLS relocations, don't generate the
3549          PLT and GOT entries they require.  */
3550       if ((info->flags & DF_BIND_NOW))
3551         htab->tlsdesc_plt = 0;
3552       else
3553         {
3554           htab->tlsdesc_got = htab->elf.sgot->size;
3555           htab->elf.sgot->size += GOT_ENTRY_SIZE;
3556           /* Reserve room for the initial entry.
3557              FIXME: we could probably do away with it in this case.  */
3558           if (htab->elf.splt->size == 0)
3559             htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3560           htab->tlsdesc_plt = htab->elf.splt->size;
3561           htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3562         }
3563     }
3564
3565   if (htab->elf.sgotplt)
3566     {
3567       /* Don't allocate .got.plt section if there are no GOT nor PLT
3568          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
3569       if ((htab->elf.hgot == NULL
3570            || !htab->elf.hgot->ref_regular_nonweak)
3571           && (htab->elf.sgotplt->size
3572               == get_elf_backend_data (output_bfd)->got_header_size)
3573           && (htab->elf.splt == NULL
3574               || htab->elf.splt->size == 0)
3575           && (htab->elf.sgot == NULL
3576               || htab->elf.sgot->size == 0)
3577           && (htab->elf.iplt == NULL
3578               || htab->elf.iplt->size == 0)
3579           && (htab->elf.igotplt == NULL
3580               || htab->elf.igotplt->size == 0))
3581         htab->elf.sgotplt->size = 0;
3582     }
3583
3584   if (htab->plt_eh_frame != NULL
3585       && htab->elf.splt != NULL
3586       && htab->elf.splt->size != 0
3587       && !bfd_is_abs_section (htab->elf.splt->output_section)
3588       && _bfd_elf_eh_frame_present (info))
3589     {
3590       const struct elf_x86_64_backend_data *arch_data
3591         = get_elf_x86_64_arch_data (bed);
3592       htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3593     }
3594
3595   /* We now have determined the sizes of the various dynamic sections.
3596      Allocate memory for them.  */
3597   relocs = FALSE;
3598   for (s = dynobj->sections; s != NULL; s = s->next)
3599     {
3600       if ((s->flags & SEC_LINKER_CREATED) == 0)
3601         continue;
3602
3603       if (s == htab->elf.splt
3604           || s == htab->elf.sgot
3605           || s == htab->elf.sgotplt
3606           || s == htab->elf.iplt
3607           || s == htab->elf.igotplt
3608           || s == htab->plt_bnd
3609           || s == htab->plt_got
3610           || s == htab->plt_eh_frame
3611           || s == htab->sdynbss)
3612         {
3613           /* Strip this section if we don't need it; see the
3614              comment below.  */
3615         }
3616       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3617         {
3618           if (s->size != 0 && s != htab->elf.srelplt)
3619             relocs = TRUE;
3620
3621           /* We use the reloc_count field as a counter if we need
3622              to copy relocs into the output file.  */
3623           if (s != htab->elf.srelplt)
3624             s->reloc_count = 0;
3625         }
3626       else
3627         {
3628           /* It's not one of our sections, so don't allocate space.  */
3629           continue;
3630         }
3631
3632       if (s->size == 0)
3633         {
3634           /* If we don't need this section, strip it from the
3635              output file.  This is mostly to handle .rela.bss and
3636              .rela.plt.  We must create both sections in
3637              create_dynamic_sections, because they must be created
3638              before the linker maps input sections to output
3639              sections.  The linker does that before
3640              adjust_dynamic_symbol is called, and it is that
3641              function which decides whether anything needs to go
3642              into these sections.  */
3643
3644           s->flags |= SEC_EXCLUDE;
3645           continue;
3646         }
3647
3648       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3649         continue;
3650
3651       /* Allocate memory for the section contents.  We use bfd_zalloc
3652          here in case unused entries are not reclaimed before the
3653          section's contents are written out.  This should not happen,
3654          but this way if it does, we get a R_X86_64_NONE reloc instead
3655          of garbage.  */
3656       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3657       if (s->contents == NULL)
3658         return FALSE;
3659     }
3660
3661   if (htab->plt_eh_frame != NULL
3662       && htab->plt_eh_frame->contents != NULL)
3663     {
3664       const struct elf_x86_64_backend_data *arch_data
3665         = get_elf_x86_64_arch_data (bed);
3666
3667       memcpy (htab->plt_eh_frame->contents,
3668               arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3669       bfd_put_32 (dynobj, htab->elf.splt->size,
3670                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3671     }
3672
3673   if (htab->elf.dynamic_sections_created)
3674     {
3675       /* Add some entries to the .dynamic section.  We fill in the
3676          values later, in elf_x86_64_finish_dynamic_sections, but we
3677          must add the entries now so that we get the correct size for
3678          the .dynamic section.  The DT_DEBUG entry is filled in by the
3679          dynamic linker and used by the debugger.  */
3680 #define add_dynamic_entry(TAG, VAL) \
3681   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3682
3683       if (bfd_link_executable (info))
3684         {
3685           if (!add_dynamic_entry (DT_DEBUG, 0))
3686             return FALSE;
3687         }
3688
3689       if (htab->elf.splt->size != 0)
3690         {
3691           /* DT_PLTGOT is used by prelink even if there is no PLT
3692              relocation.  */
3693           if (!add_dynamic_entry (DT_PLTGOT, 0))
3694             return FALSE;
3695
3696           if (htab->elf.srelplt->size != 0)
3697             {
3698               if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3699                   || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3700                   || !add_dynamic_entry (DT_JMPREL, 0))
3701                 return FALSE;
3702             }
3703
3704           if (htab->tlsdesc_plt
3705               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3706                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3707             return FALSE;
3708         }
3709
3710       if (relocs)
3711         {
3712           if (!add_dynamic_entry (DT_RELA, 0)
3713               || !add_dynamic_entry (DT_RELASZ, 0)
3714               || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3715             return FALSE;
3716
3717           /* If any dynamic relocs apply to a read-only section,
3718              then we need a DT_TEXTREL entry.  */
3719           if ((info->flags & DF_TEXTREL) == 0)
3720             elf_link_hash_traverse (&htab->elf,
3721                                     elf_x86_64_readonly_dynrelocs,
3722                                     info);
3723
3724           if ((info->flags & DF_TEXTREL) != 0)
3725             {
3726               if ((elf_tdata (output_bfd)->has_gnu_symbols
3727                    & elf_gnu_symbol_ifunc) == elf_gnu_symbol_ifunc)
3728                 {
3729                   info->callbacks->einfo
3730                     (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3731                   bfd_set_error (bfd_error_bad_value);
3732                   return FALSE;
3733                 }
3734
3735               if (!add_dynamic_entry (DT_TEXTREL, 0))
3736                 return FALSE;
3737             }
3738         }
3739     }
3740 #undef add_dynamic_entry
3741
3742   return TRUE;
3743 }
3744
3745 static bfd_boolean
3746 elf_x86_64_always_size_sections (bfd *output_bfd,
3747                                  struct bfd_link_info *info)
3748 {
3749   asection *tls_sec = elf_hash_table (info)->tls_sec;
3750
3751   if (tls_sec)
3752     {
3753       struct elf_link_hash_entry *tlsbase;
3754
3755       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3756                                       "_TLS_MODULE_BASE_",
3757                                       FALSE, FALSE, FALSE);
3758
3759       if (tlsbase && tlsbase->type == STT_TLS)
3760         {
3761           struct elf_x86_64_link_hash_table *htab;
3762           struct bfd_link_hash_entry *bh = NULL;
3763           const struct elf_backend_data *bed
3764             = get_elf_backend_data (output_bfd);
3765
3766           htab = elf_x86_64_hash_table (info);
3767           if (htab == NULL)
3768             return FALSE;
3769
3770           if (!(_bfd_generic_link_add_one_symbol
3771                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3772                  tls_sec, 0, NULL, FALSE,
3773                  bed->collect, &bh)))
3774             return FALSE;
3775
3776           htab->tls_module_base = bh;
3777
3778           tlsbase = (struct elf_link_hash_entry *)bh;
3779           tlsbase->def_regular = 1;
3780           tlsbase->other = STV_HIDDEN;
3781           tlsbase->root.linker_def = 1;
3782           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3783         }
3784     }
3785
3786   return TRUE;
3787 }
3788
3789 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3790    executables.  Rather than setting it to the beginning of the TLS
3791    section, we have to set it to the end.  This function may be called
3792    multiple times, it is idempotent.  */
3793
3794 static void
3795 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3796 {
3797   struct elf_x86_64_link_hash_table *htab;
3798   struct bfd_link_hash_entry *base;
3799
3800   if (!bfd_link_executable (info))
3801     return;
3802
3803   htab = elf_x86_64_hash_table (info);
3804   if (htab == NULL)
3805     return;
3806
3807   base = htab->tls_module_base;
3808   if (base == NULL)
3809     return;
3810
3811   base->u.def.value = htab->elf.tls_size;
3812 }
3813
3814 /* Return the base VMA address which should be subtracted from real addresses
3815    when resolving @dtpoff relocation.
3816    This is PT_TLS segment p_vaddr.  */
3817
3818 static bfd_vma
3819 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3820 {
3821   /* If tls_sec is NULL, we should have signalled an error already.  */
3822   if (elf_hash_table (info)->tls_sec == NULL)
3823     return 0;
3824   return elf_hash_table (info)->tls_sec->vma;
3825 }
3826
3827 /* Return the relocation value for @tpoff relocation
3828    if STT_TLS virtual address is ADDRESS.  */
3829
3830 static bfd_vma
3831 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3832 {
3833   struct elf_link_hash_table *htab = elf_hash_table (info);
3834   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3835   bfd_vma static_tls_size;
3836
3837   /* If tls_segment is NULL, we should have signalled an error already.  */
3838   if (htab->tls_sec == NULL)
3839     return 0;
3840
3841   /* Consider special static TLS alignment requirements.  */
3842   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3843   return address - static_tls_size - htab->tls_sec->vma;
3844 }
3845
3846 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3847    branch?  */
3848
3849 static bfd_boolean
3850 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3851 {
3852   /* Opcode             Instruction
3853      0xe8               call
3854      0xe9               jump
3855      0x0f 0x8x          conditional jump */
3856   return ((offset > 0
3857            && (contents [offset - 1] == 0xe8
3858                || contents [offset - 1] == 0xe9))
3859           || (offset > 1
3860               && contents [offset - 2] == 0x0f
3861               && (contents [offset - 1] & 0xf0) == 0x80));
3862 }
3863
3864 static bfd_boolean
3865 elf_x86_64_need_pic (bfd *input_bfd, struct elf_link_hash_entry *h,
3866                      reloc_howto_type *howto)
3867 {
3868   const char *fmt;
3869   const char *v;
3870   const char *pic = "";
3871
3872   switch (ELF_ST_VISIBILITY (h->other))
3873     {
3874     case STV_HIDDEN:
3875       v = _("hidden symbol");
3876       break;
3877     case STV_INTERNAL:
3878       v = _("internal symbol");
3879       break;
3880     case STV_PROTECTED:
3881       v = _("protected symbol");
3882       break;
3883     default:
3884       v = _("symbol");
3885       pic = _("; recompile with -fPIC");
3886       break;
3887     }
3888
3889   if (h->def_regular)
3890     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3891   else
3892     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3893
3894   (*_bfd_error_handler) (fmt, input_bfd, howto->name,
3895                          v,  h->root.root.string, pic);
3896   bfd_set_error (bfd_error_bad_value);
3897   return FALSE;
3898 }
3899
3900 /* Relocate an x86_64 ELF section.  */
3901
3902 static bfd_boolean
3903 elf_x86_64_relocate_section (bfd *output_bfd,
3904                              struct bfd_link_info *info,
3905                              bfd *input_bfd,
3906                              asection *input_section,
3907                              bfd_byte *contents,
3908                              Elf_Internal_Rela *relocs,
3909                              Elf_Internal_Sym *local_syms,
3910                              asection **local_sections)
3911 {
3912   struct elf_x86_64_link_hash_table *htab;
3913   Elf_Internal_Shdr *symtab_hdr;
3914   struct elf_link_hash_entry **sym_hashes;
3915   bfd_vma *local_got_offsets;
3916   bfd_vma *local_tlsdesc_gotents;
3917   Elf_Internal_Rela *rel;
3918   Elf_Internal_Rela *wrel;
3919   Elf_Internal_Rela *relend;
3920   const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3921
3922   BFD_ASSERT (is_x86_64_elf (input_bfd));
3923
3924   htab = elf_x86_64_hash_table (info);
3925   if (htab == NULL)
3926     return FALSE;
3927   symtab_hdr = &elf_symtab_hdr (input_bfd);
3928   sym_hashes = elf_sym_hashes (input_bfd);
3929   local_got_offsets = elf_local_got_offsets (input_bfd);
3930   local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3931
3932   elf_x86_64_set_tls_module_base (info);
3933
3934   rel = wrel = relocs;
3935   relend = relocs + input_section->reloc_count;
3936   for (; rel < relend; wrel++, rel++)
3937     {
3938       unsigned int r_type;
3939       reloc_howto_type *howto;
3940       unsigned long r_symndx;
3941       struct elf_link_hash_entry *h;
3942       struct elf_x86_64_link_hash_entry *eh;
3943       Elf_Internal_Sym *sym;
3944       asection *sec;
3945       bfd_vma off, offplt, plt_offset;
3946       bfd_vma relocation;
3947       bfd_boolean unresolved_reloc;
3948       bfd_reloc_status_type r;
3949       int tls_type;
3950       asection *base_got, *resolved_plt;
3951       bfd_vma st_size;
3952
3953       r_type = ELF32_R_TYPE (rel->r_info);
3954       if (r_type == (int) R_X86_64_GNU_VTINHERIT
3955           || r_type == (int) R_X86_64_GNU_VTENTRY)
3956         {
3957           if (wrel != rel)
3958             *wrel = *rel;
3959           continue;
3960         }
3961
3962       if (r_type >= (int) R_X86_64_standard)
3963         {
3964           (*_bfd_error_handler)
3965             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3966              input_bfd, input_section, r_type);
3967           bfd_set_error (bfd_error_bad_value);
3968           return FALSE;
3969         }
3970
3971       if (r_type != (int) R_X86_64_32
3972           || ABI_64_P (output_bfd))
3973         howto = x86_64_elf_howto_table + r_type;
3974       else
3975         howto = (x86_64_elf_howto_table
3976                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3977       r_symndx = htab->r_sym (rel->r_info);
3978       h = NULL;
3979       sym = NULL;
3980       sec = NULL;
3981       unresolved_reloc = FALSE;
3982       if (r_symndx < symtab_hdr->sh_info)
3983         {
3984           sym = local_syms + r_symndx;
3985           sec = local_sections[r_symndx];
3986
3987           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3988                                                 &sec, rel);
3989           st_size = sym->st_size;
3990
3991           /* Relocate against local STT_GNU_IFUNC symbol.  */
3992           if (!bfd_link_relocatable (info)
3993               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3994             {
3995               h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3996                                                  rel, FALSE);
3997               if (h == NULL)
3998                 abort ();
3999
4000               /* Set STT_GNU_IFUNC symbol value.  */
4001               h->root.u.def.value = sym->st_value;
4002               h->root.u.def.section = sec;
4003             }
4004         }
4005       else
4006         {
4007           bfd_boolean warned ATTRIBUTE_UNUSED;
4008           bfd_boolean ignored ATTRIBUTE_UNUSED;
4009
4010           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4011                                    r_symndx, symtab_hdr, sym_hashes,
4012                                    h, sec, relocation,
4013                                    unresolved_reloc, warned, ignored);
4014           st_size = h->size;
4015         }
4016
4017       if (sec != NULL && discarded_section (sec))
4018         {
4019           _bfd_clear_contents (howto, input_bfd, input_section,
4020                                contents + rel->r_offset);
4021           wrel->r_offset = rel->r_offset;
4022           wrel->r_info = 0;
4023           wrel->r_addend = 0;
4024
4025           /* For ld -r, remove relocations in debug sections against
4026              sections defined in discarded sections.  Not done for
4027              eh_frame editing code expects to be present.  */
4028            if (bfd_link_relocatable (info)
4029                && (input_section->flags & SEC_DEBUGGING))
4030              wrel--;
4031
4032           continue;
4033         }
4034
4035       if (bfd_link_relocatable (info))
4036         {
4037           if (wrel != rel)
4038             *wrel = *rel;
4039           continue;
4040         }
4041
4042       if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
4043         {
4044           if (r_type == R_X86_64_64)
4045             {
4046               /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4047                  zero-extend it to 64bit if addend is zero.  */
4048               r_type = R_X86_64_32;
4049               memset (contents + rel->r_offset + 4, 0, 4);
4050             }
4051           else if (r_type == R_X86_64_SIZE64)
4052             {
4053               /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4054                  zero-extend it to 64bit if addend is zero.  */
4055               r_type = R_X86_64_SIZE32;
4056               memset (contents + rel->r_offset + 4, 0, 4);
4057             }
4058         }
4059
4060       eh = (struct elf_x86_64_link_hash_entry *) h;
4061
4062       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4063          it here if it is defined in a non-shared object.  */
4064       if (h != NULL
4065           && h->type == STT_GNU_IFUNC
4066           && h->def_regular)
4067         {
4068           bfd_vma plt_index;
4069           const char *name;
4070
4071           if ((input_section->flags & SEC_ALLOC) == 0)
4072             {
4073               /* Dynamic relocs are not propagated for SEC_DEBUGGING
4074                  sections because such sections are not SEC_ALLOC and
4075                  thus ld.so will not process them.  */
4076               if ((input_section->flags & SEC_DEBUGGING) != 0)
4077                 continue;
4078               abort ();
4079             }
4080           else if (h->plt.offset == (bfd_vma) -1)
4081             abort ();
4082
4083           /* STT_GNU_IFUNC symbol must go through PLT.  */
4084           if (htab->elf.splt != NULL)
4085             {
4086               if (htab->plt_bnd != NULL)
4087                 {
4088                   resolved_plt = htab->plt_bnd;
4089                   plt_offset = eh->plt_bnd.offset;
4090                 }
4091               else
4092                 {
4093                   resolved_plt = htab->elf.splt;
4094                   plt_offset =  h->plt.offset;
4095                 }
4096             }
4097           else
4098             {
4099               resolved_plt = htab->elf.iplt;
4100               plt_offset =  h->plt.offset;
4101             }
4102
4103           relocation = (resolved_plt->output_section->vma
4104                         + resolved_plt->output_offset + plt_offset);
4105
4106           switch (r_type)
4107             {
4108             default:
4109               if (h->root.root.string)
4110                 name = h->root.root.string;
4111               else
4112                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4113                                          NULL);
4114               (*_bfd_error_handler)
4115                 (_("%B: relocation %s against STT_GNU_IFUNC "
4116                    "symbol `%s' isn't handled by %s"), input_bfd,
4117                  howto->name, name, __FUNCTION__);
4118               bfd_set_error (bfd_error_bad_value);
4119               return FALSE;
4120
4121             case R_X86_64_32S:
4122               if (bfd_link_pic (info))
4123                 abort ();
4124               goto do_relocation;
4125
4126             case R_X86_64_32:
4127               if (ABI_64_P (output_bfd))
4128                 goto do_relocation;
4129               /* FALLTHROUGH */
4130             case R_X86_64_64:
4131               if (rel->r_addend != 0)
4132                 {
4133                   if (h->root.root.string)
4134                     name = h->root.root.string;
4135                   else
4136                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4137                                              sym, NULL);
4138                   (*_bfd_error_handler)
4139                     (_("%B: relocation %s against STT_GNU_IFUNC "
4140                        "symbol `%s' has non-zero addend: %d"),
4141                      input_bfd, howto->name, name, rel->r_addend);
4142                   bfd_set_error (bfd_error_bad_value);
4143                   return FALSE;
4144                 }
4145
4146               /* Generate dynamic relcoation only when there is a
4147                  non-GOT reference in a shared object.  */
4148               if (bfd_link_pic (info) && h->non_got_ref)
4149                 {
4150                   Elf_Internal_Rela outrel;
4151                   asection *sreloc;
4152
4153                   /* Need a dynamic relocation to get the real function
4154                      address.  */
4155                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4156                                                              info,
4157                                                              input_section,
4158                                                              rel->r_offset);
4159                   if (outrel.r_offset == (bfd_vma) -1
4160                       || outrel.r_offset == (bfd_vma) -2)
4161                     abort ();
4162
4163                   outrel.r_offset += (input_section->output_section->vma
4164                                       + input_section->output_offset);
4165
4166                   if (h->dynindx == -1
4167                       || h->forced_local
4168                       || bfd_link_executable (info))
4169                     {
4170                       /* This symbol is resolved locally.  */
4171                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4172                       outrel.r_addend = (h->root.u.def.value
4173                                          + h->root.u.def.section->output_section->vma
4174                                          + h->root.u.def.section->output_offset);
4175                     }
4176                   else
4177                     {
4178                       outrel.r_info = htab->r_info (h->dynindx, r_type);
4179                       outrel.r_addend = 0;
4180                     }
4181
4182                   sreloc = htab->elf.irelifunc;
4183                   elf_append_rela (output_bfd, sreloc, &outrel);
4184
4185                   /* If this reloc is against an external symbol, we
4186                      do not want to fiddle with the addend.  Otherwise,
4187                      we need to include the symbol value so that it
4188                      becomes an addend for the dynamic reloc.  For an
4189                      internal symbol, we have updated addend.  */
4190                   continue;
4191                 }
4192               /* FALLTHROUGH */
4193             case R_X86_64_PC32:
4194             case R_X86_64_PC32_BND:
4195             case R_X86_64_PC64:
4196             case R_X86_64_PLT32:
4197             case R_X86_64_PLT32_BND:
4198               goto do_relocation;
4199
4200             case R_X86_64_GOTPCREL:
4201             case R_X86_64_GOTPCRELX:
4202             case R_X86_64_REX_GOTPCRELX:
4203             case R_X86_64_GOTPCREL64:
4204               base_got = htab->elf.sgot;
4205               off = h->got.offset;
4206
4207               if (base_got == NULL)
4208                 abort ();
4209
4210               if (off == (bfd_vma) -1)
4211                 {
4212                   /* We can't use h->got.offset here to save state, or
4213                      even just remember the offset, as finish_dynamic_symbol
4214                      would use that as offset into .got.  */
4215
4216                   if (htab->elf.splt != NULL)
4217                     {
4218                       plt_index = h->plt.offset / plt_entry_size - 1;
4219                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
4220                       base_got = htab->elf.sgotplt;
4221                     }
4222                   else
4223                     {
4224                       plt_index = h->plt.offset / plt_entry_size;
4225                       off = plt_index * GOT_ENTRY_SIZE;
4226                       base_got = htab->elf.igotplt;
4227                     }
4228
4229                   if (h->dynindx == -1
4230                       || h->forced_local
4231                       || info->symbolic)
4232                     {
4233                       /* This references the local defitionion.  We must
4234                          initialize this entry in the global offset table.
4235                          Since the offset must always be a multiple of 8,
4236                          we use the least significant bit to record
4237                          whether we have initialized it already.
4238
4239                          When doing a dynamic link, we create a .rela.got
4240                          relocation entry to initialize the value.  This
4241                          is done in the finish_dynamic_symbol routine.   */
4242                       if ((off & 1) != 0)
4243                         off &= ~1;
4244                       else
4245                         {
4246                           bfd_put_64 (output_bfd, relocation,
4247                                       base_got->contents + off);
4248                           /* Note that this is harmless for the GOTPLT64
4249                              case, as -1 | 1 still is -1.  */
4250                           h->got.offset |= 1;
4251                         }
4252                     }
4253                 }
4254
4255               relocation = (base_got->output_section->vma
4256                             + base_got->output_offset + off);
4257
4258               goto do_relocation;
4259             }
4260         }
4261
4262       /* When generating a shared object, the relocations handled here are
4263          copied into the output file to be resolved at run time.  */
4264       switch (r_type)
4265         {
4266         case R_X86_64_GOT32:
4267         case R_X86_64_GOT64:
4268           /* Relocation is to the entry for this symbol in the global
4269              offset table.  */
4270         case R_X86_64_GOTPCREL:
4271         case R_X86_64_GOTPCRELX:
4272         case R_X86_64_REX_GOTPCRELX:
4273         case R_X86_64_GOTPCREL64:
4274           /* Use global offset table entry as symbol value.  */
4275         case R_X86_64_GOTPLT64:
4276           /* This is obsolete and treated the the same as GOT64.  */
4277           base_got = htab->elf.sgot;
4278
4279           if (htab->elf.sgot == NULL)
4280             abort ();
4281
4282           if (h != NULL)
4283             {
4284               bfd_boolean dyn;
4285
4286               off = h->got.offset;
4287               if (h->needs_plt
4288                   && h->plt.offset != (bfd_vma)-1
4289                   && off == (bfd_vma)-1)
4290                 {
4291                   /* We can't use h->got.offset here to save
4292                      state, or even just remember the offset, as
4293                      finish_dynamic_symbol would use that as offset into
4294                      .got.  */
4295                   bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
4296                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
4297                   base_got = htab->elf.sgotplt;
4298                 }
4299
4300               dyn = htab->elf.dynamic_sections_created;
4301
4302               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
4303                   || (bfd_link_pic (info)
4304                       && SYMBOL_REFERENCES_LOCAL (info, h))
4305                   || (ELF_ST_VISIBILITY (h->other)
4306                       && h->root.type == bfd_link_hash_undefweak))
4307                 {
4308                   /* This is actually a static link, or it is a -Bsymbolic
4309                      link and the symbol is defined locally, or the symbol
4310                      was forced to be local because of a version file.  We
4311                      must initialize this entry in the global offset table.
4312                      Since the offset must always be a multiple of 8, we
4313                      use the least significant bit to record whether we
4314                      have initialized it already.
4315
4316                      When doing a dynamic link, we create a .rela.got
4317                      relocation entry to initialize the value.  This is
4318                      done in the finish_dynamic_symbol routine.  */
4319                   if ((off & 1) != 0)
4320                     off &= ~1;
4321                   else
4322                     {
4323                       bfd_put_64 (output_bfd, relocation,
4324                                   base_got->contents + off);
4325                       /* Note that this is harmless for the GOTPLT64 case,
4326                          as -1 | 1 still is -1.  */
4327                       h->got.offset |= 1;
4328                     }
4329                 }
4330               else
4331                 unresolved_reloc = FALSE;
4332             }
4333           else
4334             {
4335               if (local_got_offsets == NULL)
4336                 abort ();
4337
4338               off = local_got_offsets[r_symndx];
4339
4340               /* The offset must always be a multiple of 8.  We use
4341                  the least significant bit to record whether we have
4342                  already generated the necessary reloc.  */
4343               if ((off & 1) != 0)
4344                 off &= ~1;
4345               else
4346                 {
4347                   bfd_put_64 (output_bfd, relocation,
4348                               base_got->contents + off);
4349
4350                   if (bfd_link_pic (info))
4351                     {
4352                       asection *s;
4353                       Elf_Internal_Rela outrel;
4354
4355                       /* We need to generate a R_X86_64_RELATIVE reloc
4356                          for the dynamic linker.  */
4357                       s = htab->elf.srelgot;
4358                       if (s == NULL)
4359                         abort ();
4360
4361                       outrel.r_offset = (base_got->output_section->vma
4362                                          + base_got->output_offset
4363                                          + off);
4364                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4365                       outrel.r_addend = relocation;
4366                       elf_append_rela (output_bfd, s, &outrel);
4367                     }
4368
4369                   local_got_offsets[r_symndx] |= 1;
4370                 }
4371             }
4372
4373           if (off >= (bfd_vma) -2)
4374             abort ();
4375
4376           relocation = base_got->output_section->vma
4377                        + base_got->output_offset + off;
4378           if (r_type != R_X86_64_GOTPCREL
4379               && r_type != R_X86_64_GOTPCRELX
4380               && r_type != R_X86_64_REX_GOTPCRELX
4381               && r_type != R_X86_64_GOTPCREL64)
4382             relocation -= htab->elf.sgotplt->output_section->vma
4383                           - htab->elf.sgotplt->output_offset;
4384
4385           break;
4386
4387         case R_X86_64_GOTOFF64:
4388           /* Relocation is relative to the start of the global offset
4389              table.  */
4390
4391           /* Check to make sure it isn't a protected function or data
4392              symbol for shared library since it may not be local when
4393              used as function address or with copy relocation.  We also
4394              need to make sure that a symbol is referenced locally.  */
4395           if (bfd_link_pic (info) && h)
4396             {
4397               if (!h->def_regular)
4398                 {
4399                   const char *v;
4400
4401                   switch (ELF_ST_VISIBILITY (h->other))
4402                     {
4403                     case STV_HIDDEN:
4404                       v = _("hidden symbol");
4405                       break;
4406                     case STV_INTERNAL:
4407                       v = _("internal symbol");
4408                       break;
4409                     case STV_PROTECTED:
4410                       v = _("protected symbol");
4411                       break;
4412                     default:
4413                       v = _("symbol");
4414                       break;
4415                     }
4416
4417                   (*_bfd_error_handler)
4418                     (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4419                      input_bfd, v, h->root.root.string);
4420                   bfd_set_error (bfd_error_bad_value);
4421                   return FALSE;
4422                 }
4423               else if (!bfd_link_executable (info)
4424                        && !SYMBOL_REFERENCES_LOCAL (info, h)
4425                        && (h->type == STT_FUNC
4426                            || h->type == STT_OBJECT)
4427                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4428                 {
4429                   (*_bfd_error_handler)
4430                     (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4431                      input_bfd,
4432                      h->type == STT_FUNC ? "function" : "data",
4433                      h->root.root.string);
4434                   bfd_set_error (bfd_error_bad_value);
4435               return FALSE;
4436                 }
4437             }
4438
4439           /* Note that sgot is not involved in this
4440              calculation.  We always want the start of .got.plt.  If we
4441              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4442              permitted by the ABI, we might have to change this
4443              calculation.  */
4444           relocation -= htab->elf.sgotplt->output_section->vma
4445                         + htab->elf.sgotplt->output_offset;
4446           break;
4447
4448         case R_X86_64_GOTPC32:
4449         case R_X86_64_GOTPC64:
4450           /* Use global offset table as symbol value.  */
4451           relocation = htab->elf.sgotplt->output_section->vma
4452                        + htab->elf.sgotplt->output_offset;
4453           unresolved_reloc = FALSE;
4454           break;
4455
4456         case R_X86_64_PLTOFF64:
4457           /* Relocation is PLT entry relative to GOT.  For local
4458              symbols it's the symbol itself relative to GOT.  */
4459           if (h != NULL
4460               /* See PLT32 handling.  */
4461               && h->plt.offset != (bfd_vma) -1
4462               && htab->elf.splt != NULL)
4463             {
4464               if (htab->plt_bnd != NULL)
4465                 {
4466                   resolved_plt = htab->plt_bnd;
4467                   plt_offset = eh->plt_bnd.offset;
4468                 }
4469               else
4470                 {
4471                   resolved_plt = htab->elf.splt;
4472                   plt_offset = h->plt.offset;
4473                 }
4474
4475               relocation = (resolved_plt->output_section->vma
4476                             + resolved_plt->output_offset
4477                             + plt_offset);
4478               unresolved_reloc = FALSE;
4479             }
4480
4481           relocation -= htab->elf.sgotplt->output_section->vma
4482                         + htab->elf.sgotplt->output_offset;
4483           break;
4484
4485         case R_X86_64_PLT32:
4486         case R_X86_64_PLT32_BND:
4487           /* Relocation is to the entry for this symbol in the
4488              procedure linkage table.  */
4489
4490           /* Resolve a PLT32 reloc against a local symbol directly,
4491              without using the procedure linkage table.  */
4492           if (h == NULL)
4493             break;
4494
4495           if ((h->plt.offset == (bfd_vma) -1
4496                && eh->plt_got.offset == (bfd_vma) -1)
4497               || htab->elf.splt == NULL)
4498             {
4499               /* We didn't make a PLT entry for this symbol.  This
4500                  happens when statically linking PIC code, or when
4501                  using -Bsymbolic.  */
4502               break;
4503             }
4504
4505           if (h->plt.offset != (bfd_vma) -1)
4506             {
4507               if (htab->plt_bnd != NULL)
4508                 {
4509                   resolved_plt = htab->plt_bnd;
4510                   plt_offset = eh->plt_bnd.offset;
4511                 }
4512               else
4513                 {
4514                   resolved_plt = htab->elf.splt;
4515                   plt_offset = h->plt.offset;
4516                 }
4517             }
4518           else
4519             {
4520               /* Use the GOT PLT.  */
4521               resolved_plt = htab->plt_got;
4522               plt_offset = eh->plt_got.offset;
4523             }
4524
4525           relocation = (resolved_plt->output_section->vma
4526                         + resolved_plt->output_offset
4527                         + plt_offset);
4528           unresolved_reloc = FALSE;
4529           break;
4530
4531         case R_X86_64_SIZE32:
4532         case R_X86_64_SIZE64:
4533           /* Set to symbol size.  */
4534           relocation = st_size;
4535           goto direct;
4536
4537         case R_X86_64_PC8:
4538         case R_X86_64_PC16:
4539         case R_X86_64_PC32:
4540         case R_X86_64_PC32_BND:
4541           /* Don't complain about -fPIC if the symbol is undefined when
4542              building executable.  */
4543           if (bfd_link_pic (info)
4544               && (input_section->flags & SEC_ALLOC) != 0
4545               && (input_section->flags & SEC_READONLY) != 0
4546               && h != NULL
4547               && !(bfd_link_executable (info)
4548                    && h->root.type == bfd_link_hash_undefined))
4549             {
4550               bfd_boolean fail = FALSE;
4551               bfd_boolean branch
4552                 = ((r_type == R_X86_64_PC32
4553                     || r_type == R_X86_64_PC32_BND)
4554                    && is_32bit_relative_branch (contents, rel->r_offset));
4555
4556               if (SYMBOL_REFERENCES_LOCAL (info, h))
4557                 {
4558                   /* Symbol is referenced locally.  Make sure it is
4559                      defined locally or for a branch.  */
4560                   fail = !h->def_regular && !branch;
4561                 }
4562               else if (!(bfd_link_executable (info)
4563                          && (h->needs_copy || eh->needs_copy)))
4564                 {
4565                   /* Symbol doesn't need copy reloc and isn't referenced
4566                      locally.  We only allow branch to symbol with
4567                      non-default visibility. */
4568                   fail = (!branch
4569                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4570                 }
4571
4572               if (fail)
4573                 return elf_x86_64_need_pic (input_bfd, h, howto);
4574             }
4575           /* Fall through.  */
4576
4577         case R_X86_64_8:
4578         case R_X86_64_16:
4579         case R_X86_64_32:
4580         case R_X86_64_PC64:
4581         case R_X86_64_64:
4582           /* FIXME: The ABI says the linker should make sure the value is
4583              the same when it's zeroextended to 64 bit.  */
4584
4585 direct:
4586           if ((input_section->flags & SEC_ALLOC) == 0)
4587             break;
4588
4589            /* Don't copy a pc-relative relocation into the output file
4590               if the symbol needs copy reloc or the symbol is undefined
4591               when building executable.  Copy dynamic function pointer
4592               relocations.  */
4593           if ((bfd_link_pic (info)
4594                && !(bfd_link_executable (info)
4595                     && h != NULL
4596                     && (h->needs_copy
4597                         || eh->needs_copy
4598                         || h->root.type == bfd_link_hash_undefined)
4599                     && IS_X86_64_PCREL_TYPE (r_type))
4600                && (h == NULL
4601                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4602                    || h->root.type != bfd_link_hash_undefweak)
4603                && ((! IS_X86_64_PCREL_TYPE (r_type)
4604                       && r_type != R_X86_64_SIZE32
4605                       && r_type != R_X86_64_SIZE64)
4606                    || ! SYMBOL_CALLS_LOCAL (info, h)))
4607               || (ELIMINATE_COPY_RELOCS
4608                   && !bfd_link_pic (info)
4609                   && h != NULL
4610                   && h->dynindx != -1
4611                   && (!h->non_got_ref || eh->func_pointer_refcount > 0)
4612                   && ((h->def_dynamic
4613                        && !h->def_regular)
4614                       || h->root.type == bfd_link_hash_undefweak
4615                       || h->root.type == bfd_link_hash_undefined)))
4616             {
4617               Elf_Internal_Rela outrel;
4618               bfd_boolean skip, relocate;
4619               asection *sreloc;
4620
4621               /* When generating a shared object, these relocations
4622                  are copied into the output file to be resolved at run
4623                  time.  */
4624               skip = FALSE;
4625               relocate = FALSE;
4626
4627               outrel.r_offset =
4628                 _bfd_elf_section_offset (output_bfd, info, input_section,
4629                                          rel->r_offset);
4630               if (outrel.r_offset == (bfd_vma) -1)
4631                 skip = TRUE;
4632               else if (outrel.r_offset == (bfd_vma) -2)
4633                 skip = TRUE, relocate = TRUE;
4634
4635               outrel.r_offset += (input_section->output_section->vma
4636                                   + input_section->output_offset);
4637
4638               if (skip)
4639                 memset (&outrel, 0, sizeof outrel);
4640
4641               /* h->dynindx may be -1 if this symbol was marked to
4642                  become local.  */
4643               else if (h != NULL
4644                        && h->dynindx != -1
4645                        && (IS_X86_64_PCREL_TYPE (r_type)
4646                            || ! bfd_link_pic (info)
4647                            || ! SYMBOLIC_BIND (info, h)
4648                            || ! h->def_regular))
4649                 {
4650                   outrel.r_info = htab->r_info (h->dynindx, r_type);
4651                   outrel.r_addend = rel->r_addend;
4652                 }
4653               else
4654                 {
4655                   /* This symbol is local, or marked to become local.  */
4656                   if (r_type == htab->pointer_r_type)
4657                     {
4658                       relocate = TRUE;
4659                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4660                       outrel.r_addend = relocation + rel->r_addend;
4661                     }
4662                   else if (r_type == R_X86_64_64
4663                            && !ABI_64_P (output_bfd))
4664                     {
4665                       relocate = TRUE;
4666                       outrel.r_info = htab->r_info (0,
4667                                                     R_X86_64_RELATIVE64);
4668                       outrel.r_addend = relocation + rel->r_addend;
4669                       /* Check addend overflow.  */
4670                       if ((outrel.r_addend & 0x80000000)
4671                           != (rel->r_addend & 0x80000000))
4672                         {
4673                           const char *name;
4674                           int addend = rel->r_addend;
4675                           if (h && h->root.root.string)
4676                             name = h->root.root.string;
4677                           else
4678                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4679                                                      sym, NULL);
4680                           if (addend < 0)
4681                             (*_bfd_error_handler)
4682                               (_("%B: addend -0x%x in relocation %s against "
4683                                  "symbol `%s' at 0x%lx in section `%A' is "
4684                                  "out of range"),
4685                                input_bfd, input_section, addend,
4686                                howto->name, name,
4687                                (unsigned long) rel->r_offset);
4688                           else
4689                             (*_bfd_error_handler)
4690                               (_("%B: addend 0x%x in relocation %s against "
4691                                  "symbol `%s' at 0x%lx in section `%A' is "
4692                                  "out of range"),
4693                                input_bfd, input_section, addend,
4694                                howto->name, name,
4695                                (unsigned long) rel->r_offset);
4696                           bfd_set_error (bfd_error_bad_value);
4697                           return FALSE;
4698                         }
4699                     }
4700                   else
4701                     {
4702                       long sindx;
4703
4704                       if (bfd_is_abs_section (sec))
4705                         sindx = 0;
4706                       else if (sec == NULL || sec->owner == NULL)
4707                         {
4708                           bfd_set_error (bfd_error_bad_value);
4709                           return FALSE;
4710                         }
4711                       else
4712                         {
4713                           asection *osec;
4714
4715                           /* We are turning this relocation into one
4716                              against a section symbol.  It would be
4717                              proper to subtract the symbol's value,
4718                              osec->vma, from the emitted reloc addend,
4719                              but ld.so expects buggy relocs.  */
4720                           osec = sec->output_section;
4721                           sindx = elf_section_data (osec)->dynindx;
4722                           if (sindx == 0)
4723                             {
4724                               asection *oi = htab->elf.text_index_section;
4725                               sindx = elf_section_data (oi)->dynindx;
4726                             }
4727                           BFD_ASSERT (sindx != 0);
4728                         }
4729
4730                       outrel.r_info = htab->r_info (sindx, r_type);
4731                       outrel.r_addend = relocation + rel->r_addend;
4732                     }
4733                 }
4734
4735               sreloc = elf_section_data (input_section)->sreloc;
4736
4737               if (sreloc == NULL || sreloc->contents == NULL)
4738                 {
4739                   r = bfd_reloc_notsupported;
4740                   goto check_relocation_error;
4741                 }
4742
4743               elf_append_rela (output_bfd, sreloc, &outrel);
4744
4745               /* If this reloc is against an external symbol, we do
4746                  not want to fiddle with the addend.  Otherwise, we
4747                  need to include the symbol value so that it becomes
4748                  an addend for the dynamic reloc.  */
4749               if (! relocate)
4750                 continue;
4751             }
4752
4753           break;
4754
4755         case R_X86_64_TLSGD:
4756         case R_X86_64_GOTPC32_TLSDESC:
4757         case R_X86_64_TLSDESC_CALL:
4758         case R_X86_64_GOTTPOFF:
4759           tls_type = GOT_UNKNOWN;
4760           if (h == NULL && local_got_offsets)
4761             tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4762           else if (h != NULL)
4763             tls_type = elf_x86_64_hash_entry (h)->tls_type;
4764
4765           if (! elf_x86_64_tls_transition (info, input_bfd,
4766                                            input_section, contents,
4767                                            symtab_hdr, sym_hashes,
4768                                            &r_type, tls_type, rel,
4769                                            relend, h, r_symndx))
4770             return FALSE;
4771
4772           if (r_type == R_X86_64_TPOFF32)
4773             {
4774               bfd_vma roff = rel->r_offset;
4775
4776               BFD_ASSERT (! unresolved_reloc);
4777
4778               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4779                 {
4780                   /* GD->LE transition.  For 64bit, change
4781                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4782                      .word 0x6666; rex64; call __tls_get_addr
4783                      into:
4784                      movq %fs:0, %rax
4785                      leaq foo@tpoff(%rax), %rax
4786                      For 32bit, change
4787                      leaq foo@tlsgd(%rip), %rdi
4788                      .word 0x6666; rex64; call __tls_get_addr
4789                      into:
4790                      movl %fs:0, %eax
4791                      leaq foo@tpoff(%rax), %rax
4792                      For largepic, change:
4793                      leaq foo@tlsgd(%rip), %rdi
4794                      movabsq $__tls_get_addr@pltoff, %rax
4795                      addq %rbx, %rax
4796                      call *%rax
4797                      into:
4798                      movq %fs:0, %rax
4799                      leaq foo@tpoff(%rax), %rax
4800                      nopw 0x0(%rax,%rax,1) */
4801                   int largepic = 0;
4802                   if (ABI_64_P (output_bfd)
4803                       && contents[roff + 5] == (bfd_byte) '\xb8')
4804                     {
4805                       memcpy (contents + roff - 3,
4806                               "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4807                               "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4808                       largepic = 1;
4809                     }
4810                   else if (ABI_64_P (output_bfd))
4811                     memcpy (contents + roff - 4,
4812                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4813                             16);
4814                   else
4815                     memcpy (contents + roff - 3,
4816                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4817                             15);
4818                   bfd_put_32 (output_bfd,
4819                               elf_x86_64_tpoff (info, relocation),
4820                               contents + roff + 8 + largepic);
4821                   /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
4822                   rel++;
4823                   wrel++;
4824                   continue;
4825                 }
4826               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4827                 {
4828                   /* GDesc -> LE transition.
4829                      It's originally something like:
4830                      leaq x@tlsdesc(%rip), %rax
4831
4832                      Change it to:
4833                      movl $x@tpoff, %rax.  */
4834
4835                   unsigned int val, type;
4836
4837                   type = bfd_get_8 (input_bfd, contents + roff - 3);
4838                   val = bfd_get_8 (input_bfd, contents + roff - 1);
4839                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4840                              contents + roff - 3);
4841                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4842                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4843                              contents + roff - 1);
4844                   bfd_put_32 (output_bfd,
4845                               elf_x86_64_tpoff (info, relocation),
4846                               contents + roff);
4847                   continue;
4848                 }
4849               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4850                 {
4851                   /* GDesc -> LE transition.
4852                      It's originally:
4853                      call *(%rax)
4854                      Turn it into:
4855                      xchg %ax,%ax.  */
4856                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4857                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4858                   continue;
4859                 }
4860               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4861                 {
4862                   /* IE->LE transition:
4863                      For 64bit, originally it can be one of:
4864                      movq foo@gottpoff(%rip), %reg
4865                      addq foo@gottpoff(%rip), %reg
4866                      We change it into:
4867                      movq $foo, %reg
4868                      leaq foo(%reg), %reg
4869                      addq $foo, %reg.
4870                      For 32bit, originally it can be one of:
4871                      movq foo@gottpoff(%rip), %reg
4872                      addl foo@gottpoff(%rip), %reg
4873                      We change it into:
4874                      movq $foo, %reg
4875                      leal foo(%reg), %reg
4876                      addl $foo, %reg. */
4877
4878                   unsigned int val, type, reg;
4879
4880                   if (roff >= 3)
4881                     val = bfd_get_8 (input_bfd, contents + roff - 3);
4882                   else
4883                     val = 0;
4884                   type = bfd_get_8 (input_bfd, contents + roff - 2);
4885                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
4886                   reg >>= 3;
4887                   if (type == 0x8b)
4888                     {
4889                       /* movq */
4890                       if (val == 0x4c)
4891                         bfd_put_8 (output_bfd, 0x49,
4892                                    contents + roff - 3);
4893                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4894                         bfd_put_8 (output_bfd, 0x41,
4895                                    contents + roff - 3);
4896                       bfd_put_8 (output_bfd, 0xc7,
4897                                  contents + roff - 2);
4898                       bfd_put_8 (output_bfd, 0xc0 | reg,
4899                                  contents + roff - 1);
4900                     }
4901                   else if (reg == 4)
4902                     {
4903                       /* addq/addl -> addq/addl - addressing with %rsp/%r12
4904                          is special  */
4905                       if (val == 0x4c)
4906                         bfd_put_8 (output_bfd, 0x49,
4907                                    contents + roff - 3);
4908                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4909                         bfd_put_8 (output_bfd, 0x41,
4910                                    contents + roff - 3);
4911                       bfd_put_8 (output_bfd, 0x81,
4912                                  contents + roff - 2);
4913                       bfd_put_8 (output_bfd, 0xc0 | reg,
4914                                  contents + roff - 1);
4915                     }
4916                   else
4917                     {
4918                       /* addq/addl -> leaq/leal */
4919                       if (val == 0x4c)
4920                         bfd_put_8 (output_bfd, 0x4d,
4921                                    contents + roff - 3);
4922                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4923                         bfd_put_8 (output_bfd, 0x45,
4924                                    contents + roff - 3);
4925                       bfd_put_8 (output_bfd, 0x8d,
4926                                  contents + roff - 2);
4927                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4928                                  contents + roff - 1);
4929                     }
4930                   bfd_put_32 (output_bfd,
4931                               elf_x86_64_tpoff (info, relocation),
4932                               contents + roff);
4933                   continue;
4934                 }
4935               else
4936                 BFD_ASSERT (FALSE);
4937             }
4938
4939           if (htab->elf.sgot == NULL)
4940             abort ();
4941
4942           if (h != NULL)
4943             {
4944               off = h->got.offset;
4945               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4946             }
4947           else
4948             {
4949               if (local_got_offsets == NULL)
4950                 abort ();
4951
4952               off = local_got_offsets[r_symndx];
4953               offplt = local_tlsdesc_gotents[r_symndx];
4954             }
4955
4956           if ((off & 1) != 0)
4957             off &= ~1;
4958           else
4959             {
4960               Elf_Internal_Rela outrel;
4961               int dr_type, indx;
4962               asection *sreloc;
4963
4964               if (htab->elf.srelgot == NULL)
4965                 abort ();
4966
4967               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4968
4969               if (GOT_TLS_GDESC_P (tls_type))
4970                 {
4971                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4972                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4973                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4974                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4975                                      + htab->elf.sgotplt->output_offset
4976                                      + offplt
4977                                      + htab->sgotplt_jump_table_size);
4978                   sreloc = htab->elf.srelplt;
4979                   if (indx == 0)
4980                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4981                   else
4982                     outrel.r_addend = 0;
4983                   elf_append_rela (output_bfd, sreloc, &outrel);
4984                 }
4985
4986               sreloc = htab->elf.srelgot;
4987
4988               outrel.r_offset = (htab->elf.sgot->output_section->vma
4989                                  + htab->elf.sgot->output_offset + off);
4990
4991               if (GOT_TLS_GD_P (tls_type))
4992                 dr_type = R_X86_64_DTPMOD64;
4993               else if (GOT_TLS_GDESC_P (tls_type))
4994                 goto dr_done;
4995               else
4996                 dr_type = R_X86_64_TPOFF64;
4997
4998               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4999               outrel.r_addend = 0;
5000               if ((dr_type == R_X86_64_TPOFF64
5001                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
5002                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5003               outrel.r_info = htab->r_info (indx, dr_type);
5004
5005               elf_append_rela (output_bfd, sreloc, &outrel);
5006
5007               if (GOT_TLS_GD_P (tls_type))
5008                 {
5009                   if (indx == 0)
5010                     {
5011                       BFD_ASSERT (! unresolved_reloc);
5012                       bfd_put_64 (output_bfd,
5013                                   relocation - elf_x86_64_dtpoff_base (info),
5014                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5015                     }
5016                   else
5017                     {
5018                       bfd_put_64 (output_bfd, 0,
5019                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5020                       outrel.r_info = htab->r_info (indx,
5021                                                     R_X86_64_DTPOFF64);
5022                       outrel.r_offset += GOT_ENTRY_SIZE;
5023                       elf_append_rela (output_bfd, sreloc,
5024                                                 &outrel);
5025                     }
5026                 }
5027
5028             dr_done:
5029               if (h != NULL)
5030                 h->got.offset |= 1;
5031               else
5032                 local_got_offsets[r_symndx] |= 1;
5033             }
5034
5035           if (off >= (bfd_vma) -2
5036               && ! GOT_TLS_GDESC_P (tls_type))
5037             abort ();
5038           if (r_type == ELF32_R_TYPE (rel->r_info))
5039             {
5040               if (r_type == R_X86_64_GOTPC32_TLSDESC
5041                   || r_type == R_X86_64_TLSDESC_CALL)
5042                 relocation = htab->elf.sgotplt->output_section->vma
5043                   + htab->elf.sgotplt->output_offset
5044                   + offplt + htab->sgotplt_jump_table_size;
5045               else
5046                 relocation = htab->elf.sgot->output_section->vma
5047                   + htab->elf.sgot->output_offset + off;
5048               unresolved_reloc = FALSE;
5049             }
5050           else
5051             {
5052               bfd_vma roff = rel->r_offset;
5053
5054               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
5055                 {
5056                   /* GD->IE transition.  For 64bit, change
5057                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5058                      .word 0x6666; rex64; call __tls_get_addr@plt
5059                      into:
5060                      movq %fs:0, %rax
5061                      addq foo@gottpoff(%rip), %rax
5062                      For 32bit, change
5063                      leaq foo@tlsgd(%rip), %rdi
5064                      .word 0x6666; rex64; call __tls_get_addr@plt
5065                      into:
5066                      movl %fs:0, %eax
5067                      addq foo@gottpoff(%rip), %rax
5068                      For largepic, change:
5069                      leaq foo@tlsgd(%rip), %rdi
5070                      movabsq $__tls_get_addr@pltoff, %rax
5071                      addq %rbx, %rax
5072                      call *%rax
5073                      into:
5074                      movq %fs:0, %rax
5075                      addq foo@gottpoff(%rax), %rax
5076                      nopw 0x0(%rax,%rax,1) */
5077                   int largepic = 0;
5078                   if (ABI_64_P (output_bfd)
5079                       && contents[roff + 5] == (bfd_byte) '\xb8')
5080                     {
5081                       memcpy (contents + roff - 3,
5082                               "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5083                               "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5084                       largepic = 1;
5085                     }
5086                   else if (ABI_64_P (output_bfd))
5087                     memcpy (contents + roff - 4,
5088                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5089                             16);
5090                   else
5091                     memcpy (contents + roff - 3,
5092                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5093                             15);
5094
5095                   relocation = (htab->elf.sgot->output_section->vma
5096                                 + htab->elf.sgot->output_offset + off
5097                                 - roff
5098                                 - largepic
5099                                 - input_section->output_section->vma
5100                                 - input_section->output_offset
5101                                 - 12);
5102                   bfd_put_32 (output_bfd, relocation,
5103                               contents + roff + 8 + largepic);
5104                   /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
5105                   rel++;
5106                   wrel++;
5107                   continue;
5108                 }
5109               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5110                 {
5111                   /* GDesc -> IE transition.
5112                      It's originally something like:
5113                      leaq x@tlsdesc(%rip), %rax
5114
5115                      Change it to:
5116                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
5117
5118                   /* Now modify the instruction as appropriate. To
5119                      turn a leaq into a movq in the form we use it, it
5120                      suffices to change the second byte from 0x8d to
5121                      0x8b.  */
5122                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
5123
5124                   bfd_put_32 (output_bfd,
5125                               htab->elf.sgot->output_section->vma
5126                               + htab->elf.sgot->output_offset + off
5127                               - rel->r_offset
5128                               - input_section->output_section->vma
5129                               - input_section->output_offset
5130                               - 4,
5131                               contents + roff);
5132                   continue;
5133                 }
5134               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5135                 {
5136                   /* GDesc -> IE transition.
5137                      It's originally:
5138                      call *(%rax)
5139
5140                      Change it to:
5141                      xchg %ax, %ax.  */
5142
5143                   bfd_put_8 (output_bfd, 0x66, contents + roff);
5144                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5145                   continue;
5146                 }
5147               else
5148                 BFD_ASSERT (FALSE);
5149             }
5150           break;
5151
5152         case R_X86_64_TLSLD:
5153           if (! elf_x86_64_tls_transition (info, input_bfd,
5154                                            input_section, contents,
5155                                            symtab_hdr, sym_hashes,
5156                                            &r_type, GOT_UNKNOWN,
5157                                            rel, relend, h, r_symndx))
5158             return FALSE;
5159
5160           if (r_type != R_X86_64_TLSLD)
5161             {
5162               /* LD->LE transition:
5163                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5164                  For 64bit, we change it into:
5165                  .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5166                  For 32bit, we change it into:
5167                  nopl 0x0(%rax); movl %fs:0, %eax.
5168                  For largepic, change:
5169                  leaq foo@tlsgd(%rip), %rdi
5170                  movabsq $__tls_get_addr@pltoff, %rax
5171                  addq %rbx, %rax
5172                  call *%rax
5173                  into:
5174                  data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5175                  movq %fs:0, %eax */
5176
5177               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
5178               if (ABI_64_P (output_bfd)
5179                   && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
5180                 memcpy (contents + rel->r_offset - 3,
5181                         "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5182                         "\x64\x48\x8b\x04\x25\0\0\0", 22);
5183               else if (ABI_64_P (output_bfd))
5184                 memcpy (contents + rel->r_offset - 3,
5185                         "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5186               else
5187                 memcpy (contents + rel->r_offset - 3,
5188                         "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5189               /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
5190               rel++;
5191               wrel++;
5192               continue;
5193             }
5194
5195           if (htab->elf.sgot == NULL)
5196             abort ();
5197
5198           off = htab->tls_ld_got.offset;
5199           if (off & 1)
5200             off &= ~1;
5201           else
5202             {
5203               Elf_Internal_Rela outrel;
5204
5205               if (htab->elf.srelgot == NULL)
5206                 abort ();
5207
5208               outrel.r_offset = (htab->elf.sgot->output_section->vma
5209                                  + htab->elf.sgot->output_offset + off);
5210
5211               bfd_put_64 (output_bfd, 0,
5212                           htab->elf.sgot->contents + off);
5213               bfd_put_64 (output_bfd, 0,
5214                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5215               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
5216               outrel.r_addend = 0;
5217               elf_append_rela (output_bfd, htab->elf.srelgot,
5218                                         &outrel);
5219               htab->tls_ld_got.offset |= 1;
5220             }
5221           relocation = htab->elf.sgot->output_section->vma
5222                        + htab->elf.sgot->output_offset + off;
5223           unresolved_reloc = FALSE;
5224           break;
5225
5226         case R_X86_64_DTPOFF32:
5227           if (!bfd_link_executable (info)
5228               || (input_section->flags & SEC_CODE) == 0)
5229             relocation -= elf_x86_64_dtpoff_base (info);
5230           else
5231             relocation = elf_x86_64_tpoff (info, relocation);
5232           break;
5233
5234         case R_X86_64_TPOFF32:
5235         case R_X86_64_TPOFF64:
5236           BFD_ASSERT (bfd_link_executable (info));
5237           relocation = elf_x86_64_tpoff (info, relocation);
5238           break;
5239
5240         case R_X86_64_DTPOFF64:
5241           BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
5242           relocation -= elf_x86_64_dtpoff_base (info);
5243           break;
5244
5245         default:
5246           break;
5247         }
5248
5249       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5250          because such sections are not SEC_ALLOC and thus ld.so will
5251          not process them.  */
5252       if (unresolved_reloc
5253           && !((input_section->flags & SEC_DEBUGGING) != 0
5254                && h->def_dynamic)
5255           && _bfd_elf_section_offset (output_bfd, info, input_section,
5256                                       rel->r_offset) != (bfd_vma) -1)
5257         {
5258           (*_bfd_error_handler)
5259             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5260              input_bfd,
5261              input_section,
5262              (long) rel->r_offset,
5263              howto->name,
5264              h->root.root.string);
5265           return FALSE;
5266         }
5267
5268 do_relocation:
5269       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5270                                     contents, rel->r_offset,
5271                                     relocation, rel->r_addend);
5272
5273 check_relocation_error:
5274       if (r != bfd_reloc_ok)
5275         {
5276           const char *name;
5277
5278           if (h != NULL)
5279             name = h->root.root.string;
5280           else
5281             {
5282               name = bfd_elf_string_from_elf_section (input_bfd,
5283                                                       symtab_hdr->sh_link,
5284                                                       sym->st_name);
5285               if (name == NULL)
5286                 return FALSE;
5287               if (*name == '\0')
5288                 name = bfd_section_name (input_bfd, sec);
5289             }
5290
5291           if (r == bfd_reloc_overflow)
5292             {
5293               if (! ((*info->callbacks->reloc_overflow)
5294                      (info, (h ? &h->root : NULL), name, howto->name,
5295                       (bfd_vma) 0, input_bfd, input_section,
5296                       rel->r_offset)))
5297                 return FALSE;
5298             }
5299           else
5300             {
5301               (*_bfd_error_handler)
5302                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5303                  input_bfd, input_section,
5304                  (long) rel->r_offset, name, (int) r);
5305               return FALSE;
5306             }
5307         }
5308
5309       if (wrel != rel)
5310         *wrel = *rel;
5311     }
5312
5313   if (wrel != rel)
5314     {
5315       Elf_Internal_Shdr *rel_hdr;
5316       size_t deleted = rel - wrel;
5317
5318       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5319       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5320       if (rel_hdr->sh_size == 0)
5321         {
5322           /* It is too late to remove an empty reloc section.  Leave
5323              one NONE reloc.
5324              ??? What is wrong with an empty section???  */
5325           rel_hdr->sh_size = rel_hdr->sh_entsize;
5326           deleted -= 1;
5327         }
5328       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5329       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5330       input_section->reloc_count -= deleted;
5331     }
5332
5333   return TRUE;
5334 }
5335
5336 /* Finish up dynamic symbol handling.  We set the contents of various
5337    dynamic sections here.  */
5338
5339 static bfd_boolean
5340 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
5341                                   struct bfd_link_info *info,
5342                                   struct elf_link_hash_entry *h,
5343                                   Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5344 {
5345   struct elf_x86_64_link_hash_table *htab;
5346   const struct elf_x86_64_backend_data *abed;
5347   bfd_boolean use_plt_bnd;
5348   struct elf_x86_64_link_hash_entry *eh;
5349
5350   htab = elf_x86_64_hash_table (info);
5351   if (htab == NULL)
5352     return FALSE;
5353
5354   /* Use MPX backend data in case of BND relocation.  Use .plt_bnd
5355      section only if there is .plt section.  */
5356   use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
5357   abed = (use_plt_bnd
5358           ? &elf_x86_64_bnd_arch_bed
5359           : get_elf_x86_64_backend_data (output_bfd));
5360
5361   eh = (struct elf_x86_64_link_hash_entry *) h;
5362
5363   if (h->plt.offset != (bfd_vma) -1)
5364     {
5365       bfd_vma plt_index;
5366       bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
5367       bfd_vma plt_plt_insn_end, plt_got_insn_size;
5368       Elf_Internal_Rela rela;
5369       bfd_byte *loc;
5370       asection *plt, *gotplt, *relplt, *resolved_plt;
5371       const struct elf_backend_data *bed;
5372       bfd_vma plt_got_pcrel_offset;
5373
5374       /* When building a static executable, use .iplt, .igot.plt and
5375          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
5376       if (htab->elf.splt != NULL)
5377         {
5378           plt = htab->elf.splt;
5379           gotplt = htab->elf.sgotplt;
5380           relplt = htab->elf.srelplt;
5381         }
5382       else
5383         {
5384           plt = htab->elf.iplt;
5385           gotplt = htab->elf.igotplt;
5386           relplt = htab->elf.irelplt;
5387         }
5388
5389       /* This symbol has an entry in the procedure linkage table.  Set
5390          it up.  */
5391       if ((h->dynindx == -1
5392            && !((h->forced_local || bfd_link_executable (info))
5393                 && h->def_regular
5394                 && h->type == STT_GNU_IFUNC))
5395           || plt == NULL
5396           || gotplt == NULL
5397           || relplt == NULL)
5398         abort ();
5399
5400       /* Get the index in the procedure linkage table which
5401          corresponds to this symbol.  This is the index of this symbol
5402          in all the symbols for which we are making plt entries.  The
5403          first entry in the procedure linkage table is reserved.
5404
5405          Get the offset into the .got table of the entry that
5406          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
5407          bytes. The first three are reserved for the dynamic linker.
5408
5409          For static executables, we don't reserve anything.  */
5410
5411       if (plt == htab->elf.splt)
5412         {
5413           got_offset = h->plt.offset / abed->plt_entry_size - 1;
5414           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
5415         }
5416       else
5417         {
5418           got_offset = h->plt.offset / abed->plt_entry_size;
5419           got_offset = got_offset * GOT_ENTRY_SIZE;
5420         }
5421
5422       plt_plt_insn_end = abed->plt_plt_insn_end;
5423       plt_plt_offset = abed->plt_plt_offset;
5424       plt_got_insn_size = abed->plt_got_insn_size;
5425       plt_got_offset = abed->plt_got_offset;
5426       if (use_plt_bnd)
5427         {
5428           /* Use the second PLT with BND relocations.  */
5429           const bfd_byte *plt_entry, *plt2_entry;
5430
5431           if (eh->has_bnd_reloc)
5432             {
5433               plt_entry = elf_x86_64_bnd_plt_entry;
5434               plt2_entry = elf_x86_64_bnd_plt2_entry;
5435             }
5436           else
5437             {
5438               plt_entry = elf_x86_64_legacy_plt_entry;
5439               plt2_entry = elf_x86_64_legacy_plt2_entry;
5440
5441               /* Subtract 1 since there is no BND prefix.  */
5442               plt_plt_insn_end -= 1;
5443               plt_plt_offset -= 1;
5444               plt_got_insn_size -= 1;
5445               plt_got_offset -= 1;
5446             }
5447
5448           BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
5449                       == sizeof (elf_x86_64_legacy_plt_entry));
5450
5451           /* Fill in the entry in the procedure linkage table.  */
5452           memcpy (plt->contents + h->plt.offset,
5453                   plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
5454           /* Fill in the entry in the second PLT.  */
5455           memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
5456                   plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5457
5458           resolved_plt = htab->plt_bnd;
5459           plt_offset = eh->plt_bnd.offset;
5460         }
5461       else
5462         {
5463           /* Fill in the entry in the procedure linkage table.  */
5464           memcpy (plt->contents + h->plt.offset, abed->plt_entry,
5465                   abed->plt_entry_size);
5466
5467           resolved_plt = plt;
5468           plt_offset = h->plt.offset;
5469         }
5470
5471       /* Insert the relocation positions of the plt section.  */
5472
5473       /* Put offset the PC-relative instruction referring to the GOT entry,
5474          subtracting the size of that instruction.  */
5475       plt_got_pcrel_offset = (gotplt->output_section->vma
5476                               + gotplt->output_offset
5477                               + got_offset
5478                               - resolved_plt->output_section->vma
5479                               - resolved_plt->output_offset
5480                               - plt_offset
5481                               - plt_got_insn_size);
5482
5483       /* Check PC-relative offset overflow in PLT entry.  */
5484       if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
5485         info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5486                                 output_bfd, h->root.root.string);
5487
5488       bfd_put_32 (output_bfd, plt_got_pcrel_offset,
5489                   resolved_plt->contents + plt_offset + plt_got_offset);
5490
5491       /* Fill in the entry in the global offset table, initially this
5492          points to the second part of the PLT entry.  */
5493       bfd_put_64 (output_bfd, (plt->output_section->vma
5494                                + plt->output_offset
5495                                + h->plt.offset + abed->plt_lazy_offset),
5496                   gotplt->contents + got_offset);
5497
5498       /* Fill in the entry in the .rela.plt section.  */
5499       rela.r_offset = (gotplt->output_section->vma
5500                        + gotplt->output_offset
5501                        + got_offset);
5502       if (h->dynindx == -1
5503           || ((bfd_link_executable (info)
5504                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5505               && h->def_regular
5506               && h->type == STT_GNU_IFUNC))
5507         {
5508           /* If an STT_GNU_IFUNC symbol is locally defined, generate
5509              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
5510           rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
5511           rela.r_addend = (h->root.u.def.value
5512                            + h->root.u.def.section->output_section->vma
5513                            + h->root.u.def.section->output_offset);
5514           /* R_X86_64_IRELATIVE comes last.  */
5515           plt_index = htab->next_irelative_index--;
5516         }
5517       else
5518         {
5519           rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
5520           rela.r_addend = 0;
5521           plt_index = htab->next_jump_slot_index++;
5522         }
5523
5524       /* Don't fill PLT entry for static executables.  */
5525       if (plt == htab->elf.splt)
5526         {
5527           bfd_vma plt0_offset = h->plt.offset + plt_plt_insn_end;
5528
5529           /* Put relocation index.  */
5530           bfd_put_32 (output_bfd, plt_index,
5531                       plt->contents + h->plt.offset + abed->plt_reloc_offset);
5532
5533           /* Put offset for jmp .PLT0 and check for overflow.  We don't
5534              check relocation index for overflow since branch displacement
5535              will overflow first.  */
5536           if (plt0_offset > 0x80000000)
5537             info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5538                                     output_bfd, h->root.root.string);
5539           bfd_put_32 (output_bfd, - plt0_offset,
5540                       plt->contents + h->plt.offset + plt_plt_offset);
5541         }
5542
5543       bed = get_elf_backend_data (output_bfd);
5544       loc = relplt->contents + plt_index * bed->s->sizeof_rela;
5545       bed->s->swap_reloca_out (output_bfd, &rela, loc);
5546     }
5547   else if (eh->plt_got.offset != (bfd_vma) -1)
5548     {
5549       bfd_vma got_offset, plt_offset, plt_got_offset, plt_got_insn_size;
5550       asection *plt, *got;
5551       bfd_boolean got_after_plt;
5552       int32_t got_pcrel_offset;
5553       const bfd_byte *got_plt_entry;
5554
5555       /* Set the entry in the GOT procedure linkage table.  */
5556       plt = htab->plt_got;
5557       got = htab->elf.sgot;
5558       got_offset = h->got.offset;
5559
5560       if (got_offset == (bfd_vma) -1
5561           || h->type == STT_GNU_IFUNC
5562           || plt == NULL
5563           || got == NULL)
5564         abort ();
5565
5566       /* Use the second PLT entry template for the GOT PLT since they
5567          are the identical.  */
5568       plt_got_insn_size = elf_x86_64_bnd_arch_bed.plt_got_insn_size;
5569       plt_got_offset = elf_x86_64_bnd_arch_bed.plt_got_offset;
5570       if (eh->has_bnd_reloc)
5571         got_plt_entry = elf_x86_64_bnd_plt2_entry;
5572       else
5573         {
5574           got_plt_entry = elf_x86_64_legacy_plt2_entry;
5575
5576           /* Subtract 1 since there is no BND prefix.  */
5577           plt_got_insn_size -= 1;
5578           plt_got_offset -= 1;
5579         }
5580
5581       /* Fill in the entry in the GOT procedure linkage table.  */
5582       plt_offset = eh->plt_got.offset;
5583       memcpy (plt->contents + plt_offset,
5584               got_plt_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5585
5586       /* Put offset the PC-relative instruction referring to the GOT
5587          entry, subtracting the size of that instruction.  */
5588       got_pcrel_offset = (got->output_section->vma
5589                           + got->output_offset
5590                           + got_offset
5591                           - plt->output_section->vma
5592                           - plt->output_offset
5593                           - plt_offset
5594                           - plt_got_insn_size);
5595
5596       /* Check PC-relative offset overflow in GOT PLT entry.  */
5597       got_after_plt = got->output_section->vma > plt->output_section->vma;
5598       if ((got_after_plt && got_pcrel_offset < 0)
5599           || (!got_after_plt && got_pcrel_offset > 0))
5600         info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5601                                 output_bfd, h->root.root.string);
5602
5603       bfd_put_32 (output_bfd, got_pcrel_offset,
5604                   plt->contents + plt_offset + plt_got_offset);
5605     }
5606
5607   if (!h->def_regular
5608       && (h->plt.offset != (bfd_vma) -1
5609           || eh->plt_got.offset != (bfd_vma) -1))
5610     {
5611       /* Mark the symbol as undefined, rather than as defined in
5612          the .plt section.  Leave the value if there were any
5613          relocations where pointer equality matters (this is a clue
5614          for the dynamic linker, to make function pointer
5615          comparisons work between an application and shared
5616          library), otherwise set it to zero.  If a function is only
5617          called from a binary, there is no need to slow down
5618          shared libraries because of that.  */
5619       sym->st_shndx = SHN_UNDEF;
5620       if (!h->pointer_equality_needed)
5621         sym->st_value = 0;
5622     }
5623
5624   if (h->got.offset != (bfd_vma) -1
5625       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
5626       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
5627     {
5628       Elf_Internal_Rela rela;
5629
5630       /* This symbol has an entry in the global offset table.  Set it
5631          up.  */
5632       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5633         abort ();
5634
5635       rela.r_offset = (htab->elf.sgot->output_section->vma
5636                        + htab->elf.sgot->output_offset
5637                        + (h->got.offset &~ (bfd_vma) 1));
5638
5639       /* If this is a static link, or it is a -Bsymbolic link and the
5640          symbol is defined locally or was forced to be local because
5641          of a version file, we just want to emit a RELATIVE reloc.
5642          The entry in the global offset table will already have been
5643          initialized in the relocate_section function.  */
5644       if (h->def_regular
5645           && h->type == STT_GNU_IFUNC)
5646         {
5647           if (bfd_link_pic (info))
5648             {
5649               /* Generate R_X86_64_GLOB_DAT.  */
5650               goto do_glob_dat;
5651             }
5652           else
5653             {
5654               asection *plt;
5655
5656               if (!h->pointer_equality_needed)
5657                 abort ();
5658
5659               /* For non-shared object, we can't use .got.plt, which
5660                  contains the real function addres if we need pointer
5661                  equality.  We load the GOT entry with the PLT entry.  */
5662               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5663               bfd_put_64 (output_bfd, (plt->output_section->vma
5664                                        + plt->output_offset
5665                                        + h->plt.offset),
5666                           htab->elf.sgot->contents + h->got.offset);
5667               return TRUE;
5668             }
5669         }
5670       else if (bfd_link_pic (info)
5671                && SYMBOL_REFERENCES_LOCAL (info, h))
5672         {
5673           if (!h->def_regular)
5674             return FALSE;
5675           BFD_ASSERT((h->got.offset & 1) != 0);
5676           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5677           rela.r_addend = (h->root.u.def.value
5678                            + h->root.u.def.section->output_section->vma
5679                            + h->root.u.def.section->output_offset);
5680         }
5681       else
5682         {
5683           BFD_ASSERT((h->got.offset & 1) == 0);
5684 do_glob_dat:
5685           bfd_put_64 (output_bfd, (bfd_vma) 0,
5686                       htab->elf.sgot->contents + h->got.offset);
5687           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5688           rela.r_addend = 0;
5689         }
5690
5691       elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5692     }
5693
5694   if (h->needs_copy)
5695     {
5696       Elf_Internal_Rela rela;
5697
5698       /* This symbol needs a copy reloc.  Set it up.  */
5699
5700       if (h->dynindx == -1
5701           || (h->root.type != bfd_link_hash_defined
5702               && h->root.type != bfd_link_hash_defweak)
5703           || htab->srelbss == NULL)
5704         abort ();
5705
5706       rela.r_offset = (h->root.u.def.value
5707                        + h->root.u.def.section->output_section->vma
5708                        + h->root.u.def.section->output_offset);
5709       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5710       rela.r_addend = 0;
5711       elf_append_rela (output_bfd, htab->srelbss, &rela);
5712     }
5713
5714   return TRUE;
5715 }
5716
5717 /* Finish up local dynamic symbol handling.  We set the contents of
5718    various dynamic sections here.  */
5719
5720 static bfd_boolean
5721 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5722 {
5723   struct elf_link_hash_entry *h
5724     = (struct elf_link_hash_entry *) *slot;
5725   struct bfd_link_info *info
5726     = (struct bfd_link_info *) inf;
5727
5728   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5729                                              info, h, NULL);
5730 }
5731
5732 /* Used to decide how to sort relocs in an optimal manner for the
5733    dynamic linker, before writing them out.  */
5734
5735 static enum elf_reloc_type_class
5736 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
5737                              const asection *rel_sec ATTRIBUTE_UNUSED,
5738                              const Elf_Internal_Rela *rela)
5739 {
5740   bfd *abfd = info->output_bfd;
5741   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5742   struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info);
5743
5744   if (htab->elf.dynsym != NULL
5745       && htab->elf.dynsym->contents != NULL)
5746     {
5747       /* Check relocation against STT_GNU_IFUNC symbol if there are
5748          dynamic symbols.  */
5749       unsigned long r_symndx = htab->r_sym (rela->r_info);
5750       Elf_Internal_Sym sym;
5751       if (!bed->s->swap_symbol_in (abfd,
5752                                    (htab->elf.dynsym->contents
5753                                     + r_symndx * bed->s->sizeof_sym),
5754                                    0, &sym))
5755         abort ();
5756
5757       if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5758         return reloc_class_ifunc;
5759     }
5760
5761   switch ((int) ELF32_R_TYPE (rela->r_info))
5762     {
5763     case R_X86_64_RELATIVE:
5764     case R_X86_64_RELATIVE64:
5765       return reloc_class_relative;
5766     case R_X86_64_JUMP_SLOT:
5767       return reloc_class_plt;
5768     case R_X86_64_COPY:
5769       return reloc_class_copy;
5770     default:
5771       return reloc_class_normal;
5772     }
5773 }
5774
5775 /* Finish up the dynamic sections.  */
5776
5777 static bfd_boolean
5778 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5779                                     struct bfd_link_info *info)
5780 {
5781   struct elf_x86_64_link_hash_table *htab;
5782   bfd *dynobj;
5783   asection *sdyn;
5784   const struct elf_x86_64_backend_data *abed;
5785
5786   htab = elf_x86_64_hash_table (info);
5787   if (htab == NULL)
5788     return FALSE;
5789
5790   /* Use MPX backend data in case of BND relocation.  Use .plt_bnd
5791      section only if there is .plt section.  */
5792   abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5793           ? &elf_x86_64_bnd_arch_bed
5794           : get_elf_x86_64_backend_data (output_bfd));
5795
5796   dynobj = htab->elf.dynobj;
5797   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5798
5799   if (htab->elf.dynamic_sections_created)
5800     {
5801       bfd_byte *dyncon, *dynconend;
5802       const struct elf_backend_data *bed;
5803       bfd_size_type sizeof_dyn;
5804
5805       if (sdyn == NULL || htab->elf.sgot == NULL)
5806         abort ();
5807
5808       bed = get_elf_backend_data (dynobj);
5809       sizeof_dyn = bed->s->sizeof_dyn;
5810       dyncon = sdyn->contents;
5811       dynconend = sdyn->contents + sdyn->size;
5812       for (; dyncon < dynconend; dyncon += sizeof_dyn)
5813         {
5814           Elf_Internal_Dyn dyn;
5815           asection *s;
5816
5817           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5818
5819           switch (dyn.d_tag)
5820             {
5821             default:
5822               continue;
5823
5824             case DT_PLTGOT:
5825               s = htab->elf.sgotplt;
5826               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5827               break;
5828
5829             case DT_JMPREL:
5830               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5831               break;
5832
5833             case DT_PLTRELSZ:
5834               s = htab->elf.srelplt->output_section;
5835               dyn.d_un.d_val = s->size;
5836               break;
5837
5838             case DT_RELASZ:
5839               /* The procedure linkage table relocs (DT_JMPREL) should
5840                  not be included in the overall relocs (DT_RELA).
5841                  Therefore, we override the DT_RELASZ entry here to
5842                  make it not include the JMPREL relocs.  Since the
5843                  linker script arranges for .rela.plt to follow all
5844                  other relocation sections, we don't have to worry
5845                  about changing the DT_RELA entry.  */
5846               if (htab->elf.srelplt != NULL)
5847                 {
5848                   s = htab->elf.srelplt->output_section;
5849                   dyn.d_un.d_val -= s->size;
5850                 }
5851               break;
5852
5853             case DT_TLSDESC_PLT:
5854               s = htab->elf.splt;
5855               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5856                 + htab->tlsdesc_plt;
5857               break;
5858
5859             case DT_TLSDESC_GOT:
5860               s = htab->elf.sgot;
5861               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5862                 + htab->tlsdesc_got;
5863               break;
5864             }
5865
5866           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5867         }
5868
5869       /* Fill in the special first entry in the procedure linkage table.  */
5870       if (htab->elf.splt && htab->elf.splt->size > 0)
5871         {
5872           /* Fill in the first entry in the procedure linkage table.  */
5873           memcpy (htab->elf.splt->contents,
5874                   abed->plt0_entry, abed->plt_entry_size);
5875           /* Add offset for pushq GOT+8(%rip), since the instruction
5876              uses 6 bytes subtract this value.  */
5877           bfd_put_32 (output_bfd,
5878                       (htab->elf.sgotplt->output_section->vma
5879                        + htab->elf.sgotplt->output_offset
5880                        + 8
5881                        - htab->elf.splt->output_section->vma
5882                        - htab->elf.splt->output_offset
5883                        - 6),
5884                       htab->elf.splt->contents + abed->plt0_got1_offset);
5885           /* Add offset for the PC-relative instruction accessing GOT+16,
5886              subtracting the offset to the end of that instruction.  */
5887           bfd_put_32 (output_bfd,
5888                       (htab->elf.sgotplt->output_section->vma
5889                        + htab->elf.sgotplt->output_offset
5890                        + 16
5891                        - htab->elf.splt->output_section->vma
5892                        - htab->elf.splt->output_offset
5893                        - abed->plt0_got2_insn_end),
5894                       htab->elf.splt->contents + abed->plt0_got2_offset);
5895
5896           elf_section_data (htab->elf.splt->output_section)
5897             ->this_hdr.sh_entsize = abed->plt_entry_size;
5898
5899           if (htab->tlsdesc_plt)
5900             {
5901               bfd_put_64 (output_bfd, (bfd_vma) 0,
5902                           htab->elf.sgot->contents + htab->tlsdesc_got);
5903
5904               memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5905                       abed->plt0_entry, abed->plt_entry_size);
5906
5907               /* Add offset for pushq GOT+8(%rip), since the
5908                  instruction uses 6 bytes subtract this value.  */
5909               bfd_put_32 (output_bfd,
5910                           (htab->elf.sgotplt->output_section->vma
5911                            + htab->elf.sgotplt->output_offset
5912                            + 8
5913                            - htab->elf.splt->output_section->vma
5914                            - htab->elf.splt->output_offset
5915                            - htab->tlsdesc_plt
5916                            - 6),
5917                           htab->elf.splt->contents
5918                           + htab->tlsdesc_plt + abed->plt0_got1_offset);
5919           /* Add offset for the PC-relative instruction accessing GOT+TDG,
5920              where TGD stands for htab->tlsdesc_got, subtracting the offset
5921              to the end of that instruction.  */
5922               bfd_put_32 (output_bfd,
5923                           (htab->elf.sgot->output_section->vma
5924                            + htab->elf.sgot->output_offset
5925                            + htab->tlsdesc_got
5926                            - htab->elf.splt->output_section->vma
5927                            - htab->elf.splt->output_offset
5928                            - htab->tlsdesc_plt
5929                            - abed->plt0_got2_insn_end),
5930                           htab->elf.splt->contents
5931                           + htab->tlsdesc_plt + abed->plt0_got2_offset);
5932             }
5933         }
5934     }
5935
5936   if (htab->plt_bnd != NULL)
5937     elf_section_data (htab->plt_bnd->output_section)
5938       ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
5939
5940   if (htab->elf.sgotplt)
5941     {
5942       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5943         {
5944           (*_bfd_error_handler)
5945             (_("discarded output section: `%A'"), htab->elf.sgotplt);
5946           return FALSE;
5947         }
5948
5949       /* Fill in the first three entries in the global offset table.  */
5950       if (htab->elf.sgotplt->size > 0)
5951         {
5952           /* Set the first entry in the global offset table to the address of
5953              the dynamic section.  */
5954           if (sdyn == NULL)
5955             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
5956           else
5957             bfd_put_64 (output_bfd,
5958                         sdyn->output_section->vma + sdyn->output_offset,
5959                         htab->elf.sgotplt->contents);
5960           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
5961           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
5962           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
5963         }
5964
5965       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
5966         GOT_ENTRY_SIZE;
5967     }
5968
5969   /* Adjust .eh_frame for .plt section.  */
5970   if (htab->plt_eh_frame != NULL
5971       && htab->plt_eh_frame->contents != NULL)
5972     {
5973       if (htab->elf.splt != NULL
5974           && htab->elf.splt->size != 0
5975           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5976           && htab->elf.splt->output_section != NULL
5977           && htab->plt_eh_frame->output_section != NULL)
5978         {
5979           bfd_vma plt_start = htab->elf.splt->output_section->vma;
5980           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5981                                    + htab->plt_eh_frame->output_offset
5982                                    + PLT_FDE_START_OFFSET;
5983           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5984                              htab->plt_eh_frame->contents
5985                              + PLT_FDE_START_OFFSET);
5986         }
5987       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5988         {
5989           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5990                                                  htab->plt_eh_frame,
5991                                                  htab->plt_eh_frame->contents))
5992             return FALSE;
5993         }
5994     }
5995
5996   if (htab->elf.sgot && htab->elf.sgot->size > 0)
5997     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
5998       = GOT_ENTRY_SIZE;
5999
6000   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
6001   htab_traverse (htab->loc_hash_table,
6002                  elf_x86_64_finish_local_dynamic_symbol,
6003                  info);
6004
6005   return TRUE;
6006 }
6007
6008 /* Return an array of PLT entry symbol values.  */
6009
6010 static bfd_vma *
6011 elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
6012                             asection *relplt)
6013 {
6014   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6015   arelent *p;
6016   long count, i;
6017   bfd_vma *plt_sym_val;
6018   bfd_vma plt_offset;
6019   bfd_byte *plt_contents;
6020   const struct elf_x86_64_backend_data *bed;
6021   Elf_Internal_Shdr *hdr;
6022   asection *plt_bnd;
6023
6024   /* Get the .plt section contents.  PLT passed down may point to the
6025      .plt.bnd section.  Make sure that PLT always points to the .plt
6026      section.  */
6027   plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
6028   if (plt_bnd)
6029     {
6030       if (plt != plt_bnd)
6031         abort ();
6032       plt = bfd_get_section_by_name (abfd, ".plt");
6033       if (plt == NULL)
6034         abort ();
6035       bed = &elf_x86_64_bnd_arch_bed;
6036     }
6037   else
6038     bed = get_elf_x86_64_backend_data (abfd);
6039
6040   plt_contents = (bfd_byte *) bfd_malloc (plt->size);
6041   if (plt_contents == NULL)
6042     return NULL;
6043   if (!bfd_get_section_contents (abfd, (asection *) plt,
6044                                  plt_contents, 0, plt->size))
6045     {
6046 bad_return:
6047       free (plt_contents);
6048       return NULL;
6049     }
6050
6051   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6052   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
6053     goto bad_return;
6054
6055   hdr = &elf_section_data (relplt)->this_hdr;
6056   count = relplt->size / hdr->sh_entsize;
6057
6058   plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
6059   if (plt_sym_val == NULL)
6060     goto bad_return;
6061
6062   for (i = 0; i < count; i++)
6063     plt_sym_val[i] = -1;
6064
6065   plt_offset = bed->plt_entry_size;
6066   p = relplt->relocation;
6067   for (i = 0; i < count; i++, p++)
6068     {
6069       long reloc_index;
6070
6071       /* Skip unknown relocation.  */
6072       if (p->howto == NULL)
6073         continue;
6074
6075       if (p->howto->type != R_X86_64_JUMP_SLOT
6076           && p->howto->type != R_X86_64_IRELATIVE)
6077         continue;
6078
6079       reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
6080                                      + bed->plt_reloc_offset));
6081       if (reloc_index < count)
6082         {
6083           if (plt_bnd)
6084             {
6085               /* This is the index in .plt section.  */
6086               long plt_index = plt_offset / bed->plt_entry_size;
6087               /* Store VMA + the offset in .plt.bnd section.  */
6088               plt_sym_val[reloc_index] =
6089                 (plt_bnd->vma
6090                  + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
6091             }
6092           else
6093             plt_sym_val[reloc_index] = plt->vma + plt_offset;
6094         }
6095       plt_offset += bed->plt_entry_size;
6096
6097       /* PR binutils/18437: Skip extra relocations in the .rela.plt
6098          section.  */
6099       if (plt_offset >= plt->size)
6100         break;
6101     }
6102
6103   free (plt_contents);
6104
6105   return plt_sym_val;
6106 }
6107
6108 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6109    support.  */
6110
6111 static long
6112 elf_x86_64_get_synthetic_symtab (bfd *abfd,
6113                                  long symcount,
6114                                  asymbol **syms,
6115                                  long dynsymcount,
6116                                  asymbol **dynsyms,
6117                                  asymbol **ret)
6118 {
6119   /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6120      as PLT if it exists.  */
6121   asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
6122   if (plt == NULL)
6123     plt = bfd_get_section_by_name (abfd, ".plt");
6124   return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
6125                                               dynsymcount, dynsyms, ret,
6126                                               plt,
6127                                               elf_x86_64_get_plt_sym_val);
6128 }
6129
6130 /* Handle an x86-64 specific section when reading an object file.  This
6131    is called when elfcode.h finds a section with an unknown type.  */
6132
6133 static bfd_boolean
6134 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
6135                               const char *name, int shindex)
6136 {
6137   if (hdr->sh_type != SHT_X86_64_UNWIND)
6138     return FALSE;
6139
6140   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6141     return FALSE;
6142
6143   return TRUE;
6144 }
6145
6146 /* Hook called by the linker routine which adds symbols from an object
6147    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6148    of .bss.  */
6149
6150 static bfd_boolean
6151 elf_x86_64_add_symbol_hook (bfd *abfd,
6152                             struct bfd_link_info *info,
6153                             Elf_Internal_Sym *sym,
6154                             const char **namep ATTRIBUTE_UNUSED,
6155                             flagword *flagsp ATTRIBUTE_UNUSED,
6156                             asection **secp,
6157                             bfd_vma *valp)
6158 {
6159   asection *lcomm;
6160
6161   switch (sym->st_shndx)
6162     {
6163     case SHN_X86_64_LCOMMON:
6164       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
6165       if (lcomm == NULL)
6166         {
6167           lcomm = bfd_make_section_with_flags (abfd,
6168                                                "LARGE_COMMON",
6169                                                (SEC_ALLOC
6170                                                 | SEC_IS_COMMON
6171                                                 | SEC_LINKER_CREATED));
6172           if (lcomm == NULL)
6173             return FALSE;
6174           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
6175         }
6176       *secp = lcomm;
6177       *valp = sym->st_size;
6178       return TRUE;
6179     }
6180
6181   if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
6182       && (abfd->flags & DYNAMIC) == 0
6183       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
6184     elf_tdata (info->output_bfd)->has_gnu_symbols
6185       |= elf_gnu_symbol_unique;
6186
6187   return TRUE;
6188 }
6189
6190
6191 /* Given a BFD section, try to locate the corresponding ELF section
6192    index.  */
6193
6194 static bfd_boolean
6195 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6196                                          asection *sec, int *index_return)
6197 {
6198   if (sec == &_bfd_elf_large_com_section)
6199     {
6200       *index_return = SHN_X86_64_LCOMMON;
6201       return TRUE;
6202     }
6203   return FALSE;
6204 }
6205
6206 /* Process a symbol.  */
6207
6208 static void
6209 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6210                               asymbol *asym)
6211 {
6212   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6213
6214   switch (elfsym->internal_elf_sym.st_shndx)
6215     {
6216     case SHN_X86_64_LCOMMON:
6217       asym->section = &_bfd_elf_large_com_section;
6218       asym->value = elfsym->internal_elf_sym.st_size;
6219       /* Common symbol doesn't set BSF_GLOBAL.  */
6220       asym->flags &= ~BSF_GLOBAL;
6221       break;
6222     }
6223 }
6224
6225 static bfd_boolean
6226 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
6227 {
6228   return (sym->st_shndx == SHN_COMMON
6229           || sym->st_shndx == SHN_X86_64_LCOMMON);
6230 }
6231
6232 static unsigned int
6233 elf_x86_64_common_section_index (asection *sec)
6234 {
6235   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6236     return SHN_COMMON;
6237   else
6238     return SHN_X86_64_LCOMMON;
6239 }
6240
6241 static asection *
6242 elf_x86_64_common_section (asection *sec)
6243 {
6244   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6245     return bfd_com_section_ptr;
6246   else
6247     return &_bfd_elf_large_com_section;
6248 }
6249
6250 static bfd_boolean
6251 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
6252                          const Elf_Internal_Sym *sym,
6253                          asection **psec,
6254                          bfd_boolean newdef,
6255                          bfd_boolean olddef,
6256                          bfd *oldbfd,
6257                          const asection *oldsec)
6258 {
6259   /* A normal common symbol and a large common symbol result in a
6260      normal common symbol.  We turn the large common symbol into a
6261      normal one.  */
6262   if (!olddef
6263       && h->root.type == bfd_link_hash_common
6264       && !newdef
6265       && bfd_is_com_section (*psec)
6266       && oldsec != *psec)
6267     {
6268       if (sym->st_shndx == SHN_COMMON
6269           && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
6270         {
6271           h->root.u.c.p->section
6272             = bfd_make_section_old_way (oldbfd, "COMMON");
6273           h->root.u.c.p->section->flags = SEC_ALLOC;
6274         }
6275       else if (sym->st_shndx == SHN_X86_64_LCOMMON
6276                && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
6277         *psec = bfd_com_section_ptr;
6278     }
6279
6280   return TRUE;
6281 }
6282
6283 static int
6284 elf_x86_64_additional_program_headers (bfd *abfd,
6285                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
6286 {
6287   asection *s;
6288   int count = 0;
6289
6290   /* Check to see if we need a large readonly segment.  */
6291   s = bfd_get_section_by_name (abfd, ".lrodata");
6292   if (s && (s->flags & SEC_LOAD))
6293     count++;
6294
6295   /* Check to see if we need a large data segment.  Since .lbss sections
6296      is placed right after the .bss section, there should be no need for
6297      a large data segment just because of .lbss.  */
6298   s = bfd_get_section_by_name (abfd, ".ldata");
6299   if (s && (s->flags & SEC_LOAD))
6300     count++;
6301
6302   return count;
6303 }
6304
6305 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
6306
6307 static bfd_boolean
6308 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
6309 {
6310   if (h->plt.offset != (bfd_vma) -1
6311       && !h->def_regular
6312       && !h->pointer_equality_needed)
6313     return FALSE;
6314
6315   return _bfd_elf_hash_symbol (h);
6316 }
6317
6318 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6319
6320 static bfd_boolean
6321 elf_x86_64_relocs_compatible (const bfd_target *input,
6322                               const bfd_target *output)
6323 {
6324   return ((xvec_get_elf_backend_data (input)->s->elfclass
6325            == xvec_get_elf_backend_data (output)->s->elfclass)
6326           && _bfd_elf_relocs_compatible (input, output));
6327 }
6328
6329 static const struct bfd_elf_special_section
6330   elf_x86_64_special_sections[]=
6331 {
6332   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6333   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6334   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
6335   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6336   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6337   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6338   { NULL,                       0,          0, 0,            0 }
6339 };
6340
6341 #define TARGET_LITTLE_SYM                   x86_64_elf64_vec
6342 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
6343 #define ELF_ARCH                            bfd_arch_i386
6344 #define ELF_TARGET_ID                       X86_64_ELF_DATA
6345 #define ELF_MACHINE_CODE                    EM_X86_64
6346 #define ELF_MAXPAGESIZE                     0x200000
6347 #define ELF_MINPAGESIZE                     0x1000
6348 #define ELF_COMMONPAGESIZE                  0x1000
6349
6350 #define elf_backend_can_gc_sections         1
6351 #define elf_backend_can_refcount            1
6352 #define elf_backend_want_got_plt            1
6353 #define elf_backend_plt_readonly            1
6354 #define elf_backend_want_plt_sym            0
6355 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
6356 #define elf_backend_rela_normal             1
6357 #define elf_backend_plt_alignment           4
6358 #define elf_backend_extern_protected_data   1
6359
6360 #define elf_info_to_howto                   elf_x86_64_info_to_howto
6361
6362 #define bfd_elf64_bfd_link_hash_table_create \
6363   elf_x86_64_link_hash_table_create
6364 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
6365 #define bfd_elf64_bfd_reloc_name_lookup \
6366   elf_x86_64_reloc_name_lookup
6367
6368 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
6369 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
6370 #define elf_backend_check_relocs            elf_x86_64_check_relocs
6371 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
6372 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6373 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6374 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
6375 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
6376 #define elf_backend_gc_sweep_hook           elf_x86_64_gc_sweep_hook
6377 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
6378 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
6379 #ifdef CORE_HEADER
6380 #define elf_backend_write_core_note         elf_x86_64_write_core_note
6381 #endif
6382 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
6383 #define elf_backend_relocate_section        elf_x86_64_relocate_section
6384 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
6385 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
6386 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
6387 #define elf_backend_object_p                elf64_x86_64_elf_object_p
6388 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
6389 #define bfd_elf64_get_synthetic_symtab      elf_x86_64_get_synthetic_symtab
6390
6391 #define elf_backend_section_from_shdr \
6392         elf_x86_64_section_from_shdr
6393
6394 #define elf_backend_section_from_bfd_section \
6395   elf_x86_64_elf_section_from_bfd_section
6396 #define elf_backend_add_symbol_hook \
6397   elf_x86_64_add_symbol_hook
6398 #define elf_backend_symbol_processing \
6399   elf_x86_64_symbol_processing
6400 #define elf_backend_common_section_index \
6401   elf_x86_64_common_section_index
6402 #define elf_backend_common_section \
6403   elf_x86_64_common_section
6404 #define elf_backend_common_definition \
6405   elf_x86_64_common_definition
6406 #define elf_backend_merge_symbol \
6407   elf_x86_64_merge_symbol
6408 #define elf_backend_special_sections \
6409   elf_x86_64_special_sections
6410 #define elf_backend_additional_program_headers \
6411   elf_x86_64_additional_program_headers
6412 #define elf_backend_hash_symbol \
6413   elf_x86_64_hash_symbol
6414 #define elf_backend_omit_section_dynsym \
6415   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6416
6417 #include "elf64-target.h"
6418
6419 /* CloudABI support.  */
6420
6421 #undef  TARGET_LITTLE_SYM
6422 #define TARGET_LITTLE_SYM                   x86_64_elf64_cloudabi_vec
6423 #undef  TARGET_LITTLE_NAME
6424 #define TARGET_LITTLE_NAME                  "elf64-x86-64-cloudabi"
6425
6426 #undef  ELF_OSABI
6427 #define ELF_OSABI                           ELFOSABI_CLOUDABI
6428
6429 #undef  elf64_bed
6430 #define elf64_bed elf64_x86_64_cloudabi_bed
6431
6432 #include "elf64-target.h"
6433
6434 /* FreeBSD support.  */
6435
6436 #undef  TARGET_LITTLE_SYM
6437 #define TARGET_LITTLE_SYM                   x86_64_elf64_fbsd_vec
6438 #undef  TARGET_LITTLE_NAME
6439 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
6440
6441 #undef  ELF_OSABI
6442 #define ELF_OSABI                           ELFOSABI_FREEBSD
6443
6444 #undef  elf64_bed
6445 #define elf64_bed elf64_x86_64_fbsd_bed
6446
6447 #include "elf64-target.h"
6448
6449 /* Solaris 2 support.  */
6450
6451 #undef  TARGET_LITTLE_SYM
6452 #define TARGET_LITTLE_SYM                   x86_64_elf64_sol2_vec
6453 #undef  TARGET_LITTLE_NAME
6454 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
6455
6456 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6457    objects won't be recognized.  */
6458 #undef ELF_OSABI
6459
6460 #undef  elf64_bed
6461 #define elf64_bed                           elf64_x86_64_sol2_bed
6462
6463 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6464    boundary.  */
6465 #undef elf_backend_static_tls_alignment
6466 #define elf_backend_static_tls_alignment    16
6467
6468 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6469
6470    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6471    File, p.63.  */
6472 #undef elf_backend_want_plt_sym
6473 #define elf_backend_want_plt_sym            1
6474
6475 #include "elf64-target.h"
6476
6477 /* Native Client support.  */
6478
6479 static bfd_boolean
6480 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
6481 {
6482   /* Set the right machine number for a NaCl x86-64 ELF64 file.  */
6483   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
6484   return TRUE;
6485 }
6486
6487 #undef  TARGET_LITTLE_SYM
6488 #define TARGET_LITTLE_SYM               x86_64_elf64_nacl_vec
6489 #undef  TARGET_LITTLE_NAME
6490 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
6491 #undef  elf64_bed
6492 #define elf64_bed                       elf64_x86_64_nacl_bed
6493
6494 #undef  ELF_MAXPAGESIZE
6495 #undef  ELF_MINPAGESIZE
6496 #undef  ELF_COMMONPAGESIZE
6497 #define ELF_MAXPAGESIZE                 0x10000
6498 #define ELF_MINPAGESIZE                 0x10000
6499 #define ELF_COMMONPAGESIZE              0x10000
6500
6501 /* Restore defaults.  */
6502 #undef  ELF_OSABI
6503 #undef  elf_backend_static_tls_alignment
6504 #undef  elf_backend_want_plt_sym
6505 #define elf_backend_want_plt_sym        0
6506
6507 /* NaCl uses substantially different PLT entries for the same effects.  */
6508
6509 #undef  elf_backend_plt_alignment
6510 #define elf_backend_plt_alignment       5
6511 #define NACL_PLT_ENTRY_SIZE             64
6512 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
6513
6514 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
6515   {
6516     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
6517     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
6518     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
6519     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
6520     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
6521
6522     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
6523     0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1)     */
6524
6525     /* 32 bytes of nop to pad out to the standard size.  */
6526     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
6527     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6528     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
6529     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6530     0x66,                                  /* excess data32 prefix      */
6531     0x90                                   /* nop */
6532   };
6533
6534 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6535   {
6536     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
6537     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
6538     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
6539     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
6540
6541     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
6542     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
6543     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6544
6545     /* Lazy GOT entries point here (32-byte aligned).  */
6546     0x68,                 /* pushq immediate */
6547     0, 0, 0, 0,           /* replaced with index into relocation table.  */
6548     0xe9,                 /* jmp relative */
6549     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
6550
6551     /* 22 bytes of nop to pad out to the standard size.  */
6552     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
6553     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6554     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
6555   };
6556
6557 /* .eh_frame covering the .plt section.  */
6558
6559 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
6560   {
6561 #if (PLT_CIE_LENGTH != 20                               \
6562      || PLT_FDE_LENGTH != 36                            \
6563      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
6564      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6565 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6566 #endif
6567     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
6568     0, 0, 0, 0,                 /* CIE ID */
6569     1,                          /* CIE version */
6570     'z', 'R', 0,                /* Augmentation string */
6571     1,                          /* Code alignment factor */
6572     0x78,                       /* Data alignment factor */
6573     16,                         /* Return address column */
6574     1,                          /* Augmentation size */
6575     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6576     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6577     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
6578     DW_CFA_nop, DW_CFA_nop,
6579
6580     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
6581     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
6582     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
6583     0, 0, 0, 0,                 /* .plt size goes here */
6584     0,                          /* Augmentation size */
6585     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
6586     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6587     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
6588     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6589     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
6590     13,                         /* Block length */
6591     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
6592     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
6593     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6594     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
6595     DW_CFA_nop, DW_CFA_nop
6596   };
6597
6598 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
6599   {
6600     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
6601     elf_x86_64_nacl_plt_entry,               /* plt_entry */
6602     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
6603     2,                                       /* plt0_got1_offset */
6604     9,                                       /* plt0_got2_offset */
6605     13,                                      /* plt0_got2_insn_end */
6606     3,                                       /* plt_got_offset */
6607     33,                                      /* plt_reloc_offset */
6608     38,                                      /* plt_plt_offset */
6609     7,                                       /* plt_got_insn_size */
6610     42,                                      /* plt_plt_insn_end */
6611     32,                                      /* plt_lazy_offset */
6612     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
6613     sizeof (elf_x86_64_nacl_eh_frame_plt),   /* eh_frame_plt_size */
6614   };
6615
6616 #undef  elf_backend_arch_data
6617 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
6618
6619 #undef  elf_backend_object_p
6620 #define elf_backend_object_p                    elf64_x86_64_nacl_elf_object_p
6621 #undef  elf_backend_modify_segment_map
6622 #define elf_backend_modify_segment_map          nacl_modify_segment_map
6623 #undef  elf_backend_modify_program_headers
6624 #define elf_backend_modify_program_headers      nacl_modify_program_headers
6625 #undef  elf_backend_final_write_processing
6626 #define elf_backend_final_write_processing      nacl_final_write_processing
6627
6628 #include "elf64-target.h"
6629
6630 /* Native Client x32 support.  */
6631
6632 static bfd_boolean
6633 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
6634 {
6635   /* Set the right machine number for a NaCl x86-64 ELF32 file.  */
6636   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
6637   return TRUE;
6638 }
6639
6640 #undef  TARGET_LITTLE_SYM
6641 #define TARGET_LITTLE_SYM               x86_64_elf32_nacl_vec
6642 #undef  TARGET_LITTLE_NAME
6643 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
6644 #undef  elf32_bed
6645 #define elf32_bed                       elf32_x86_64_nacl_bed
6646
6647 #define bfd_elf32_bfd_link_hash_table_create \
6648   elf_x86_64_link_hash_table_create
6649 #define bfd_elf32_bfd_reloc_type_lookup \
6650   elf_x86_64_reloc_type_lookup
6651 #define bfd_elf32_bfd_reloc_name_lookup \
6652   elf_x86_64_reloc_name_lookup
6653 #define bfd_elf32_mkobject \
6654   elf_x86_64_mkobject
6655 #define bfd_elf32_get_synthetic_symtab \
6656   elf_x86_64_get_synthetic_symtab
6657
6658 #undef elf_backend_object_p
6659 #define elf_backend_object_p \
6660   elf32_x86_64_nacl_elf_object_p
6661
6662 #undef elf_backend_bfd_from_remote_memory
6663 #define elf_backend_bfd_from_remote_memory \
6664   _bfd_elf32_bfd_from_remote_memory
6665
6666 #undef elf_backend_size_info
6667 #define elf_backend_size_info \
6668   _bfd_elf32_size_info
6669
6670 #include "elf32-target.h"
6671
6672 /* Restore defaults.  */
6673 #undef  elf_backend_object_p
6674 #define elf_backend_object_p                elf64_x86_64_elf_object_p
6675 #undef  elf_backend_bfd_from_remote_memory
6676 #undef  elf_backend_size_info
6677 #undef  elf_backend_modify_segment_map
6678 #undef  elf_backend_modify_program_headers
6679 #undef  elf_backend_final_write_processing
6680
6681 /* Intel L1OM support.  */
6682
6683 static bfd_boolean
6684 elf64_l1om_elf_object_p (bfd *abfd)
6685 {
6686   /* Set the right machine number for an L1OM elf64 file.  */
6687   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6688   return TRUE;
6689 }
6690
6691 #undef  TARGET_LITTLE_SYM
6692 #define TARGET_LITTLE_SYM                   l1om_elf64_vec
6693 #undef  TARGET_LITTLE_NAME
6694 #define TARGET_LITTLE_NAME                  "elf64-l1om"
6695 #undef ELF_ARCH
6696 #define ELF_ARCH                            bfd_arch_l1om
6697
6698 #undef  ELF_MACHINE_CODE
6699 #define ELF_MACHINE_CODE                    EM_L1OM
6700
6701 #undef  ELF_OSABI
6702
6703 #undef  elf64_bed
6704 #define elf64_bed elf64_l1om_bed
6705
6706 #undef elf_backend_object_p
6707 #define elf_backend_object_p                elf64_l1om_elf_object_p
6708
6709 /* Restore defaults.  */
6710 #undef  ELF_MAXPAGESIZE
6711 #undef  ELF_MINPAGESIZE
6712 #undef  ELF_COMMONPAGESIZE
6713 #define ELF_MAXPAGESIZE                 0x200000
6714 #define ELF_MINPAGESIZE                 0x1000
6715 #define ELF_COMMONPAGESIZE              0x1000
6716 #undef  elf_backend_plt_alignment
6717 #define elf_backend_plt_alignment       4
6718 #undef  elf_backend_arch_data
6719 #define elf_backend_arch_data   &elf_x86_64_arch_bed
6720
6721 #include "elf64-target.h"
6722
6723 /* FreeBSD L1OM support.  */
6724
6725 #undef  TARGET_LITTLE_SYM
6726 #define TARGET_LITTLE_SYM                   l1om_elf64_fbsd_vec
6727 #undef  TARGET_LITTLE_NAME
6728 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
6729
6730 #undef  ELF_OSABI
6731 #define ELF_OSABI                           ELFOSABI_FREEBSD
6732
6733 #undef  elf64_bed
6734 #define elf64_bed elf64_l1om_fbsd_bed
6735
6736 #include "elf64-target.h"
6737
6738 /* Intel K1OM support.  */
6739
6740 static bfd_boolean
6741 elf64_k1om_elf_object_p (bfd *abfd)
6742 {
6743   /* Set the right machine number for an K1OM elf64 file.  */
6744   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6745   return TRUE;
6746 }
6747
6748 #undef  TARGET_LITTLE_SYM
6749 #define TARGET_LITTLE_SYM                   k1om_elf64_vec
6750 #undef  TARGET_LITTLE_NAME
6751 #define TARGET_LITTLE_NAME                  "elf64-k1om"
6752 #undef ELF_ARCH
6753 #define ELF_ARCH                            bfd_arch_k1om
6754
6755 #undef  ELF_MACHINE_CODE
6756 #define ELF_MACHINE_CODE                    EM_K1OM
6757
6758 #undef  ELF_OSABI
6759
6760 #undef  elf64_bed
6761 #define elf64_bed elf64_k1om_bed
6762
6763 #undef elf_backend_object_p
6764 #define elf_backend_object_p                elf64_k1om_elf_object_p
6765
6766 #undef  elf_backend_static_tls_alignment
6767
6768 #undef elf_backend_want_plt_sym
6769 #define elf_backend_want_plt_sym            0
6770
6771 #include "elf64-target.h"
6772
6773 /* FreeBSD K1OM support.  */
6774
6775 #undef  TARGET_LITTLE_SYM
6776 #define TARGET_LITTLE_SYM                   k1om_elf64_fbsd_vec
6777 #undef  TARGET_LITTLE_NAME
6778 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
6779
6780 #undef  ELF_OSABI
6781 #define ELF_OSABI                           ELFOSABI_FREEBSD
6782
6783 #undef  elf64_bed
6784 #define elf64_bed elf64_k1om_fbsd_bed
6785
6786 #include "elf64-target.h"
6787
6788 /* 32bit x86-64 support.  */
6789
6790 #undef  TARGET_LITTLE_SYM
6791 #define TARGET_LITTLE_SYM                   x86_64_elf32_vec
6792 #undef  TARGET_LITTLE_NAME
6793 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
6794 #undef  elf32_bed
6795
6796 #undef ELF_ARCH
6797 #define ELF_ARCH                            bfd_arch_i386
6798
6799 #undef  ELF_MACHINE_CODE
6800 #define ELF_MACHINE_CODE                    EM_X86_64
6801
6802 #undef  ELF_OSABI
6803
6804 #undef elf_backend_object_p
6805 #define elf_backend_object_p \
6806   elf32_x86_64_elf_object_p
6807
6808 #undef elf_backend_bfd_from_remote_memory
6809 #define elf_backend_bfd_from_remote_memory \
6810   _bfd_elf32_bfd_from_remote_memory
6811
6812 #undef elf_backend_size_info
6813 #define elf_backend_size_info \
6814   _bfd_elf32_size_info
6815
6816 #include "elf32-target.h"