bfd/elf64-x86-64.c

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