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