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