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