bfd/elf64-x86-64.c

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