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