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