bfd/elf64-x86-64.c

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