bfd/elf64-x86-64.c

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