bfd/elf64-x86-64.c

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