bfd/elf64-x86-64.c

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