bfd/elf64-x86-64.c

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