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