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