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