bfd/elf64-x86-64.c

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