bfd/elf64-x86-64.c

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