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       || bfd_is_abs_section (sec->output_section))
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                      For 64bit, 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                      For 32bit, originally it can be one of:
4292                      movq foo@gottpoff(%rip), %reg
4293                      addl foo@gottpoff(%rip), %reg
4294                      We change it into:
4295                      movq $foo, %reg
4296                      leal foo(%reg), %reg
4297                      addl $foo, %reg. */
4298
4299                   unsigned int val, type, reg;
4300
4301                   if (roff >= 3)
4302                     val = bfd_get_8 (input_bfd, contents + roff - 3);
4303                   else
4304                     val = 0;
4305                   type = bfd_get_8 (input_bfd, contents + roff - 2);
4306                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
4307                   reg >>= 3;
4308                   if (type == 0x8b)
4309                     {
4310                       /* movq */
4311                       if (val == 0x4c)
4312                         bfd_put_8 (output_bfd, 0x49,
4313                                    contents + roff - 3);
4314                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4315                         bfd_put_8 (output_bfd, 0x41,
4316                                    contents + roff - 3);
4317                       bfd_put_8 (output_bfd, 0xc7,
4318                                  contents + roff - 2);
4319                       bfd_put_8 (output_bfd, 0xc0 | reg,
4320                                  contents + roff - 1);
4321                     }
4322                   else if (reg == 4)
4323                     {
4324                       /* addq/addl -> addq/addl - addressing with %rsp/%r12
4325                          is special  */
4326                       if (val == 0x4c)
4327                         bfd_put_8 (output_bfd, 0x49,
4328                                    contents + roff - 3);
4329                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4330                         bfd_put_8 (output_bfd, 0x41,
4331                                    contents + roff - 3);
4332                       bfd_put_8 (output_bfd, 0x81,
4333                                  contents + roff - 2);
4334                       bfd_put_8 (output_bfd, 0xc0 | reg,
4335                                  contents + roff - 1);
4336                     }
4337                   else
4338                     {
4339                       /* addq/addl -> leaq/leal */
4340                       if (val == 0x4c)
4341                         bfd_put_8 (output_bfd, 0x4d,
4342                                    contents + roff - 3);
4343                       else if (!ABI_64_P (output_bfd) && val == 0x44)
4344                         bfd_put_8 (output_bfd, 0x45,
4345                                    contents + roff - 3);
4346                       bfd_put_8 (output_bfd, 0x8d,
4347                                  contents + roff - 2);
4348                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4349                                  contents + roff - 1);
4350                     }
4351                   bfd_put_32 (output_bfd,
4352                               elf_x86_64_tpoff (info, relocation),
4353                               contents + roff);
4354                   continue;
4355                 }
4356               else
4357                 BFD_ASSERT (FALSE);
4358             }
4359
4360           if (htab->elf.sgot == NULL)
4361             abort ();
4362
4363           if (h != NULL)
4364             {
4365               off = h->got.offset;
4366               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4367             }
4368           else
4369             {
4370               if (local_got_offsets == NULL)
4371                 abort ();
4372
4373               off = local_got_offsets[r_symndx];
4374               offplt = local_tlsdesc_gotents[r_symndx];
4375             }
4376
4377           if ((off & 1) != 0)
4378             off &= ~1;
4379           else
4380             {
4381               Elf_Internal_Rela outrel;
4382               int dr_type, indx;
4383               asection *sreloc;
4384
4385               if (htab->elf.srelgot == NULL)
4386                 abort ();
4387
4388               indx = h && h->dynindx != -1 ? h->dynindx : 0;
4389
4390               if (GOT_TLS_GDESC_P (tls_type))
4391                 {
4392                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4393                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4394                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4395                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4396                                      + htab->elf.sgotplt->output_offset
4397                                      + offplt
4398                                      + htab->sgotplt_jump_table_size);
4399                   sreloc = htab->elf.srelplt;
4400                   if (indx == 0)
4401                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4402                   else
4403                     outrel.r_addend = 0;
4404                   elf_append_rela (output_bfd, sreloc, &outrel);
4405                 }
4406
4407               sreloc = htab->elf.srelgot;
4408
4409               outrel.r_offset = (htab->elf.sgot->output_section->vma
4410                                  + htab->elf.sgot->output_offset + off);
4411
4412               if (GOT_TLS_GD_P (tls_type))
4413                 dr_type = R_X86_64_DTPMOD64;
4414               else if (GOT_TLS_GDESC_P (tls_type))
4415                 goto dr_done;
4416               else
4417                 dr_type = R_X86_64_TPOFF64;
4418
4419               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4420               outrel.r_addend = 0;
4421               if ((dr_type == R_X86_64_TPOFF64
4422                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
4423                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4424               outrel.r_info = htab->r_info (indx, dr_type);
4425
4426               elf_append_rela (output_bfd, sreloc, &outrel);
4427
4428               if (GOT_TLS_GD_P (tls_type))
4429                 {
4430                   if (indx == 0)
4431                     {
4432                       BFD_ASSERT (! unresolved_reloc);
4433                       bfd_put_64 (output_bfd,
4434                                   relocation - elf_x86_64_dtpoff_base (info),
4435                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4436                     }
4437                   else
4438                     {
4439                       bfd_put_64 (output_bfd, 0,
4440                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4441                       outrel.r_info = htab->r_info (indx,
4442                                                     R_X86_64_DTPOFF64);
4443                       outrel.r_offset += GOT_ENTRY_SIZE;
4444                       elf_append_rela (output_bfd, sreloc,
4445                                                 &outrel);
4446                     }
4447                 }
4448
4449             dr_done:
4450               if (h != NULL)
4451                 h->got.offset |= 1;
4452               else
4453                 local_got_offsets[r_symndx] |= 1;
4454             }
4455
4456           if (off >= (bfd_vma) -2
4457               && ! GOT_TLS_GDESC_P (tls_type))
4458             abort ();
4459           if (r_type == ELF32_R_TYPE (rel->r_info))
4460             {
4461               if (r_type == R_X86_64_GOTPC32_TLSDESC
4462                   || r_type == R_X86_64_TLSDESC_CALL)
4463                 relocation = htab->elf.sgotplt->output_section->vma
4464                   + htab->elf.sgotplt->output_offset
4465                   + offplt + htab->sgotplt_jump_table_size;
4466               else
4467                 relocation = htab->elf.sgot->output_section->vma
4468                   + htab->elf.sgot->output_offset + off;
4469               unresolved_reloc = FALSE;
4470             }
4471           else
4472             {
4473               bfd_vma roff = rel->r_offset;
4474
4475               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4476                 {
4477                   /* GD->IE transition.  For 64bit, change
4478                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4479                      .word 0x6666; rex64; call __tls_get_addr@plt
4480                      into:
4481                      movq %fs:0, %rax
4482                      addq foo@gottpoff(%rip), %rax
4483                      For 32bit, change
4484                      leaq foo@tlsgd(%rip), %rdi
4485                      .word 0x6666; rex64; call __tls_get_addr@plt
4486                      into:
4487                      movl %fs:0, %eax
4488                      addq foo@gottpoff(%rip), %rax
4489                      For largepic, change:
4490                      leaq foo@tlsgd(%rip), %rdi
4491                      movabsq $__tls_get_addr@pltoff, %rax
4492                      addq %rbx, %rax
4493                      call *%rax
4494                      into:
4495                      movq %fs:0, %rax
4496                      addq foo@gottpoff(%rax), %rax
4497                      nopw 0x0(%rax,%rax,1) */
4498                   int largepic = 0;
4499                   if (ABI_64_P (output_bfd)
4500                       && contents[roff + 5] == (bfd_byte) '\xb8')
4501                     {
4502                       memcpy (contents + roff - 3,
4503                               "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4504                               "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4505                       largepic = 1;
4506                     }
4507                   else if (ABI_64_P (output_bfd))
4508                     memcpy (contents + roff - 4,
4509                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4510                             16);
4511                   else
4512                     memcpy (contents + roff - 3,
4513                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4514                             15);
4515
4516                   relocation = (htab->elf.sgot->output_section->vma
4517                                 + htab->elf.sgot->output_offset + off
4518                                 - roff
4519                                 - largepic
4520                                 - input_section->output_section->vma
4521                                 - input_section->output_offset
4522                                 - 12);
4523                   bfd_put_32 (output_bfd, relocation,
4524                               contents + roff + 8 + largepic);
4525                   /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
4526                   rel++;
4527                   continue;
4528                 }
4529               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4530                 {
4531                   /* GDesc -> IE transition.
4532                      It's originally something like:
4533                      leaq x@tlsdesc(%rip), %rax
4534
4535                      Change it to:
4536                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
4537
4538                   /* Now modify the instruction as appropriate. To
4539                      turn a leaq into a movq in the form we use it, it
4540                      suffices to change the second byte from 0x8d to
4541                      0x8b.  */
4542                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4543
4544                   bfd_put_32 (output_bfd,
4545                               htab->elf.sgot->output_section->vma
4546                               + htab->elf.sgot->output_offset + off
4547                               - rel->r_offset
4548                               - input_section->output_section->vma
4549                               - input_section->output_offset
4550                               - 4,
4551                               contents + roff);
4552                   continue;
4553                 }
4554               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4555                 {
4556                   /* GDesc -> IE transition.
4557                      It's originally:
4558                      call *(%rax)
4559
4560                      Change it to:
4561                      xchg %ax, %ax.  */
4562
4563                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4564                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4565                   continue;
4566                 }
4567               else
4568                 BFD_ASSERT (FALSE);
4569             }
4570           break;
4571
4572         case R_X86_64_TLSLD:
4573           if (! elf_x86_64_tls_transition (info, input_bfd,
4574                                            input_section, contents,
4575                                            symtab_hdr, sym_hashes,
4576                                            &r_type, GOT_UNKNOWN,
4577                                            rel, relend, h, r_symndx))
4578             return FALSE;
4579
4580           if (r_type != R_X86_64_TLSLD)
4581             {
4582               /* LD->LE transition:
4583                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4584                  For 64bit, we change it into:
4585                  .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4586                  For 32bit, we change it into:
4587                  nopl 0x0(%rax); movl %fs:0, %eax.
4588                  For largepic, change:
4589                  leaq foo@tlsgd(%rip), %rdi
4590                  movabsq $__tls_get_addr@pltoff, %rax
4591                  addq %rbx, %rax
4592                  call *%rax
4593                  into:
4594                  data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4595                  movq %fs:0, %eax */
4596
4597               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4598               if (ABI_64_P (output_bfd)
4599                   && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
4600                 memcpy (contents + rel->r_offset - 3,
4601                         "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4602                         "\x64\x48\x8b\x04\x25\0\0\0", 22);
4603               else if (ABI_64_P (output_bfd))
4604                 memcpy (contents + rel->r_offset - 3,
4605                         "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4606               else
4607                 memcpy (contents + rel->r_offset - 3,
4608                         "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4609               /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
4610               rel++;
4611               continue;
4612             }
4613
4614           if (htab->elf.sgot == NULL)
4615             abort ();
4616
4617           off = htab->tls_ld_got.offset;
4618           if (off & 1)
4619             off &= ~1;
4620           else
4621             {
4622               Elf_Internal_Rela outrel;
4623
4624               if (htab->elf.srelgot == NULL)
4625                 abort ();
4626
4627               outrel.r_offset = (htab->elf.sgot->output_section->vma
4628                                  + htab->elf.sgot->output_offset + off);
4629
4630               bfd_put_64 (output_bfd, 0,
4631                           htab->elf.sgot->contents + off);
4632               bfd_put_64 (output_bfd, 0,
4633                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4634               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4635               outrel.r_addend = 0;
4636               elf_append_rela (output_bfd, htab->elf.srelgot,
4637                                         &outrel);
4638               htab->tls_ld_got.offset |= 1;
4639             }
4640           relocation = htab->elf.sgot->output_section->vma
4641                        + htab->elf.sgot->output_offset + off;
4642           unresolved_reloc = FALSE;
4643           break;
4644
4645         case R_X86_64_DTPOFF32:
4646           if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4647             relocation -= elf_x86_64_dtpoff_base (info);
4648           else
4649             relocation = elf_x86_64_tpoff (info, relocation);
4650           break;
4651
4652         case R_X86_64_TPOFF32:
4653         case R_X86_64_TPOFF64:
4654           BFD_ASSERT (info->executable);
4655           relocation = elf_x86_64_tpoff (info, relocation);
4656           break;
4657
4658         case R_X86_64_DTPOFF64:
4659           BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
4660           relocation -= elf_x86_64_dtpoff_base (info);
4661           break;
4662
4663         default:
4664           break;
4665         }
4666
4667       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4668          because such sections are not SEC_ALLOC and thus ld.so will
4669          not process them.  */
4670       if (unresolved_reloc
4671           && !((input_section->flags & SEC_DEBUGGING) != 0
4672                && h->def_dynamic)
4673           && _bfd_elf_section_offset (output_bfd, info, input_section,
4674                                       rel->r_offset) != (bfd_vma) -1)
4675         {
4676           (*_bfd_error_handler)
4677             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4678              input_bfd,
4679              input_section,
4680              (long) rel->r_offset,
4681              howto->name,
4682              h->root.root.string);
4683           return FALSE;
4684         }
4685
4686 do_relocation:
4687       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4688                                     contents, rel->r_offset,
4689                                     relocation, rel->r_addend);
4690
4691 check_relocation_error:
4692       if (r != bfd_reloc_ok)
4693         {
4694           const char *name;
4695
4696           if (h != NULL)
4697             name = h->root.root.string;
4698           else
4699             {
4700               name = bfd_elf_string_from_elf_section (input_bfd,
4701                                                       symtab_hdr->sh_link,
4702                                                       sym->st_name);
4703               if (name == NULL)
4704                 return FALSE;
4705               if (*name == '\0')
4706                 name = bfd_section_name (input_bfd, sec);
4707             }
4708
4709           if (r == bfd_reloc_overflow)
4710             {
4711               if (! ((*info->callbacks->reloc_overflow)
4712                      (info, (h ? &h->root : NULL), name, howto->name,
4713                       (bfd_vma) 0, input_bfd, input_section,
4714                       rel->r_offset)))
4715                 return FALSE;
4716             }
4717           else
4718             {
4719               (*_bfd_error_handler)
4720                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4721                  input_bfd, input_section,
4722                  (long) rel->r_offset, name, (int) r);
4723               return FALSE;
4724             }
4725         }
4726     }
4727
4728   return TRUE;
4729 }
4730
4731 /* Finish up dynamic symbol handling.  We set the contents of various
4732    dynamic sections here.  */
4733
4734 static bfd_boolean
4735 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4736                                   struct bfd_link_info *info,
4737                                   struct elf_link_hash_entry *h,
4738                                   Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4739 {
4740   struct elf_x86_64_link_hash_table *htab;
4741   const struct elf_x86_64_backend_data *abed;
4742   bfd_boolean use_plt_bnd;
4743
4744   htab = elf_x86_64_hash_table (info);
4745   if (htab == NULL)
4746     return FALSE;
4747
4748   /* Use MPX backend data in case of BND relocation.  Use .plt_bnd
4749      section only if there is .plt section.  */
4750   use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
4751   abed = (use_plt_bnd
4752           ? &elf_x86_64_bnd_arch_bed
4753           : get_elf_x86_64_backend_data (output_bfd));
4754
4755   if (h->plt.offset != (bfd_vma) -1)
4756     {
4757       bfd_vma plt_index;
4758       bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
4759       bfd_vma plt_plt_insn_end, plt_got_insn_size;
4760       Elf_Internal_Rela rela;
4761       bfd_byte *loc;
4762       asection *plt, *gotplt, *relplt, *resolved_plt;
4763       const struct elf_backend_data *bed;
4764
4765       /* When building a static executable, use .iplt, .igot.plt and
4766          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4767       if (htab->elf.splt != NULL)
4768         {
4769           plt = htab->elf.splt;
4770           gotplt = htab->elf.sgotplt;
4771           relplt = htab->elf.srelplt;
4772         }
4773       else
4774         {
4775           plt = htab->elf.iplt;
4776           gotplt = htab->elf.igotplt;
4777           relplt = htab->elf.irelplt;
4778         }
4779
4780       /* This symbol has an entry in the procedure linkage table.  Set
4781          it up.  */
4782       if ((h->dynindx == -1
4783            && !((h->forced_local || info->executable)
4784                 && h->def_regular
4785                 && h->type == STT_GNU_IFUNC))
4786           || plt == NULL
4787           || gotplt == NULL
4788           || relplt == NULL)
4789         abort ();
4790
4791       /* Get the index in the procedure linkage table which
4792          corresponds to this symbol.  This is the index of this symbol
4793          in all the symbols for which we are making plt entries.  The
4794          first entry in the procedure linkage table is reserved.
4795
4796          Get the offset into the .got table of the entry that
4797          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
4798          bytes. The first three are reserved for the dynamic linker.
4799
4800          For static executables, we don't reserve anything.  */
4801
4802       if (plt == htab->elf.splt)
4803         {
4804           got_offset = h->plt.offset / abed->plt_entry_size - 1;
4805           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4806         }
4807       else
4808         {
4809           got_offset = h->plt.offset / abed->plt_entry_size;
4810           got_offset = got_offset * GOT_ENTRY_SIZE;
4811         }
4812
4813       plt_plt_insn_end = abed->plt_plt_insn_end;
4814       plt_plt_offset = abed->plt_plt_offset;
4815       plt_got_insn_size = abed->plt_got_insn_size;
4816       plt_got_offset = abed->plt_got_offset;
4817       if (use_plt_bnd)
4818         {
4819           /* Use the second PLT with BND relocations.  */
4820           const bfd_byte *plt_entry, *plt2_entry;
4821           struct elf_x86_64_link_hash_entry *eh
4822             = (struct elf_x86_64_link_hash_entry *) h;
4823
4824           if (eh->has_bnd_reloc)
4825             {
4826               plt_entry = elf_x86_64_bnd_plt_entry;
4827               plt2_entry = elf_x86_64_bnd_plt2_entry;
4828             }
4829           else
4830             {
4831               plt_entry = elf_x86_64_legacy_plt_entry;
4832               plt2_entry = elf_x86_64_legacy_plt2_entry;
4833
4834               /* Subtract 1 since there is no BND prefix.  */
4835               plt_plt_insn_end -= 1;
4836               plt_plt_offset -= 1;
4837               plt_got_insn_size -= 1;
4838               plt_got_offset -= 1;
4839             }
4840
4841           BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
4842                       == sizeof (elf_x86_64_legacy_plt_entry));
4843
4844           /* Fill in the entry in the procedure linkage table.  */
4845           memcpy (plt->contents + h->plt.offset,
4846                   plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
4847           /* Fill in the entry in the second PLT.  */
4848           memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
4849                   plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
4850
4851           resolved_plt = htab->plt_bnd;
4852           plt_offset = eh->plt_bnd.offset;
4853         }
4854       else
4855         {
4856           /* Fill in the entry in the procedure linkage table.  */
4857           memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4858                   abed->plt_entry_size);
4859
4860           resolved_plt = plt;
4861           plt_offset = h->plt.offset;
4862         }
4863
4864       /* Insert the relocation positions of the plt section.  */
4865
4866       /* Put offset the PC-relative instruction referring to the GOT entry,
4867          subtracting the size of that instruction.  */
4868       bfd_put_32 (output_bfd,
4869                   (gotplt->output_section->vma
4870                    + gotplt->output_offset
4871                    + got_offset
4872                    - resolved_plt->output_section->vma
4873                    - resolved_plt->output_offset
4874                    - plt_offset
4875                    - plt_got_insn_size),
4876                   resolved_plt->contents + plt_offset + plt_got_offset);
4877
4878       /* Fill in the entry in the global offset table, initially this
4879          points to the second part of the PLT entry.  */
4880       bfd_put_64 (output_bfd, (plt->output_section->vma
4881                                + plt->output_offset
4882                                + h->plt.offset + abed->plt_lazy_offset),
4883                   gotplt->contents + got_offset);
4884
4885       /* Fill in the entry in the .rela.plt section.  */
4886       rela.r_offset = (gotplt->output_section->vma
4887                        + gotplt->output_offset
4888                        + got_offset);
4889       if (h->dynindx == -1
4890           || ((info->executable
4891                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4892               && h->def_regular
4893               && h->type == STT_GNU_IFUNC))
4894         {
4895           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4896              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
4897           rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4898           rela.r_addend = (h->root.u.def.value
4899                            + h->root.u.def.section->output_section->vma
4900                            + h->root.u.def.section->output_offset);
4901           /* R_X86_64_IRELATIVE comes last.  */
4902           plt_index = htab->next_irelative_index--;
4903         }
4904       else
4905         {
4906           rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4907           rela.r_addend = 0;
4908           plt_index = htab->next_jump_slot_index++;
4909         }
4910
4911       /* Don't fill PLT entry for static executables.  */
4912       if (plt == htab->elf.splt)
4913         {
4914           /* Put relocation index.  */
4915           bfd_put_32 (output_bfd, plt_index,
4916                       plt->contents + h->plt.offset + abed->plt_reloc_offset);
4917           /* Put offset for jmp .PLT0.  */
4918           bfd_put_32 (output_bfd, - (h->plt.offset + plt_plt_insn_end),
4919                       plt->contents + h->plt.offset + plt_plt_offset);
4920         }
4921
4922       bed = get_elf_backend_data (output_bfd);
4923       loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4924       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4925
4926       if (!h->def_regular)
4927         {
4928           /* Mark the symbol as undefined, rather than as defined in
4929              the .plt section.  Leave the value if there were any
4930              relocations where pointer equality matters (this is a clue
4931              for the dynamic linker, to make function pointer
4932              comparisons work between an application and shared
4933              library), otherwise set it to zero.  If a function is only
4934              called from a binary, there is no need to slow down
4935              shared libraries because of that.  */
4936           sym->st_shndx = SHN_UNDEF;
4937           if (!h->pointer_equality_needed)
4938             sym->st_value = 0;
4939         }
4940     }
4941
4942   if (h->got.offset != (bfd_vma) -1
4943       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4944       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4945     {
4946       Elf_Internal_Rela rela;
4947
4948       /* This symbol has an entry in the global offset table.  Set it
4949          up.  */
4950       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4951         abort ();
4952
4953       rela.r_offset = (htab->elf.sgot->output_section->vma
4954                        + htab->elf.sgot->output_offset
4955                        + (h->got.offset &~ (bfd_vma) 1));
4956
4957       /* If this is a static link, or it is a -Bsymbolic link and the
4958          symbol is defined locally or was forced to be local because
4959          of a version file, we just want to emit a RELATIVE reloc.
4960          The entry in the global offset table will already have been
4961          initialized in the relocate_section function.  */
4962       if (h->def_regular
4963           && h->type == STT_GNU_IFUNC)
4964         {
4965           if (info->shared)
4966             {
4967               /* Generate R_X86_64_GLOB_DAT.  */
4968               goto do_glob_dat;
4969             }
4970           else
4971             {
4972               asection *plt;
4973
4974               if (!h->pointer_equality_needed)
4975                 abort ();
4976
4977               /* For non-shared object, we can't use .got.plt, which
4978                  contains the real function addres if we need pointer
4979                  equality.  We load the GOT entry with the PLT entry.  */
4980               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4981               bfd_put_64 (output_bfd, (plt->output_section->vma
4982                                        + plt->output_offset
4983                                        + h->plt.offset),
4984                           htab->elf.sgot->contents + h->got.offset);
4985               return TRUE;
4986             }
4987         }
4988       else if (info->shared
4989                && SYMBOL_REFERENCES_LOCAL (info, h))
4990         {
4991           if (!h->def_regular)
4992             return FALSE;
4993           BFD_ASSERT((h->got.offset & 1) != 0);
4994           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4995           rela.r_addend = (h->root.u.def.value
4996                            + h->root.u.def.section->output_section->vma
4997                            + h->root.u.def.section->output_offset);
4998         }
4999       else
5000         {
5001           BFD_ASSERT((h->got.offset & 1) == 0);
5002 do_glob_dat:
5003           bfd_put_64 (output_bfd, (bfd_vma) 0,
5004                       htab->elf.sgot->contents + h->got.offset);
5005           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5006           rela.r_addend = 0;
5007         }
5008
5009       elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5010     }
5011
5012   if (h->needs_copy)
5013     {
5014       Elf_Internal_Rela rela;
5015
5016       /* This symbol needs a copy reloc.  Set it up.  */
5017
5018       if (h->dynindx == -1
5019           || (h->root.type != bfd_link_hash_defined
5020               && h->root.type != bfd_link_hash_defweak)
5021           || htab->srelbss == NULL)
5022         abort ();
5023
5024       rela.r_offset = (h->root.u.def.value
5025                        + h->root.u.def.section->output_section->vma
5026                        + h->root.u.def.section->output_offset);
5027       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5028       rela.r_addend = 0;
5029       elf_append_rela (output_bfd, htab->srelbss, &rela);
5030     }
5031
5032   return TRUE;
5033 }
5034
5035 /* Finish up local dynamic symbol handling.  We set the contents of
5036    various dynamic sections here.  */
5037
5038 static bfd_boolean
5039 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5040 {
5041   struct elf_link_hash_entry *h
5042     = (struct elf_link_hash_entry *) *slot;
5043   struct bfd_link_info *info
5044     = (struct bfd_link_info *) inf;
5045
5046   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5047                                              info, h, NULL);
5048 }
5049
5050 /* Used to decide how to sort relocs in an optimal manner for the
5051    dynamic linker, before writing them out.  */
5052
5053 static enum elf_reloc_type_class
5054 elf_x86_64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5055                              const asection *rel_sec ATTRIBUTE_UNUSED,
5056                              const Elf_Internal_Rela *rela)
5057 {
5058   switch ((int) ELF32_R_TYPE (rela->r_info))
5059     {
5060     case R_X86_64_RELATIVE:
5061     case R_X86_64_RELATIVE64:
5062       return reloc_class_relative;
5063     case R_X86_64_JUMP_SLOT:
5064       return reloc_class_plt;
5065     case R_X86_64_COPY:
5066       return reloc_class_copy;
5067     default:
5068       return reloc_class_normal;
5069     }
5070 }
5071
5072 /* Finish up the dynamic sections.  */
5073
5074 static bfd_boolean
5075 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5076                                     struct bfd_link_info *info)
5077 {
5078   struct elf_x86_64_link_hash_table *htab;
5079   bfd *dynobj;
5080   asection *sdyn;
5081   const struct elf_x86_64_backend_data *abed;
5082
5083   htab = elf_x86_64_hash_table (info);
5084   if (htab == NULL)
5085     return FALSE;
5086
5087   /* Use MPX backend data in case of BND relocation.  Use .plt_bnd
5088      section only if there is .plt section.  */
5089   abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5090           ? &elf_x86_64_bnd_arch_bed
5091           : get_elf_x86_64_backend_data (output_bfd));
5092
5093   dynobj = htab->elf.dynobj;
5094   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5095
5096   if (htab->elf.dynamic_sections_created)
5097     {
5098       bfd_byte *dyncon, *dynconend;
5099       const struct elf_backend_data *bed;
5100       bfd_size_type sizeof_dyn;
5101
5102       if (sdyn == NULL || htab->elf.sgot == NULL)
5103         abort ();
5104
5105       bed = get_elf_backend_data (dynobj);
5106       sizeof_dyn = bed->s->sizeof_dyn;
5107       dyncon = sdyn->contents;
5108       dynconend = sdyn->contents + sdyn->size;
5109       for (; dyncon < dynconend; dyncon += sizeof_dyn)
5110         {
5111           Elf_Internal_Dyn dyn;
5112           asection *s;
5113
5114           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5115
5116           switch (dyn.d_tag)
5117             {
5118             default:
5119               continue;
5120
5121             case DT_PLTGOT:
5122               s = htab->elf.sgotplt;
5123               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5124               break;
5125
5126             case DT_JMPREL:
5127               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5128               break;
5129
5130             case DT_PLTRELSZ:
5131               s = htab->elf.srelplt->output_section;
5132               dyn.d_un.d_val = s->size;
5133               break;
5134
5135             case DT_RELASZ:
5136               /* The procedure linkage table relocs (DT_JMPREL) should
5137                  not be included in the overall relocs (DT_RELA).
5138                  Therefore, we override the DT_RELASZ entry here to
5139                  make it not include the JMPREL relocs.  Since the
5140                  linker script arranges for .rela.plt to follow all
5141                  other relocation sections, we don't have to worry
5142                  about changing the DT_RELA entry.  */
5143               if (htab->elf.srelplt != NULL)
5144                 {
5145                   s = htab->elf.srelplt->output_section;
5146                   dyn.d_un.d_val -= s->size;
5147                 }
5148               break;
5149
5150             case DT_TLSDESC_PLT:
5151               s = htab->elf.splt;
5152               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5153                 + htab->tlsdesc_plt;
5154               break;
5155
5156             case DT_TLSDESC_GOT:
5157               s = htab->elf.sgot;
5158               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5159                 + htab->tlsdesc_got;
5160               break;
5161             }
5162
5163           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5164         }
5165
5166       /* Fill in the special first entry in the procedure linkage table.  */
5167       if (htab->elf.splt && htab->elf.splt->size > 0)
5168         {
5169           /* Fill in the first entry in the procedure linkage table.  */
5170           memcpy (htab->elf.splt->contents,
5171                   abed->plt0_entry, abed->plt_entry_size);
5172           /* Add offset for pushq GOT+8(%rip), since the instruction
5173              uses 6 bytes subtract this value.  */
5174           bfd_put_32 (output_bfd,
5175                       (htab->elf.sgotplt->output_section->vma
5176                        + htab->elf.sgotplt->output_offset
5177                        + 8
5178                        - htab->elf.splt->output_section->vma
5179                        - htab->elf.splt->output_offset
5180                        - 6),
5181                       htab->elf.splt->contents + abed->plt0_got1_offset);
5182           /* Add offset for the PC-relative instruction accessing GOT+16,
5183              subtracting the offset to the end of that instruction.  */
5184           bfd_put_32 (output_bfd,
5185                       (htab->elf.sgotplt->output_section->vma
5186                        + htab->elf.sgotplt->output_offset
5187                        + 16
5188                        - htab->elf.splt->output_section->vma
5189                        - htab->elf.splt->output_offset
5190                        - abed->plt0_got2_insn_end),
5191                       htab->elf.splt->contents + abed->plt0_got2_offset);
5192
5193           elf_section_data (htab->elf.splt->output_section)
5194             ->this_hdr.sh_entsize = abed->plt_entry_size;
5195
5196           if (htab->tlsdesc_plt)
5197             {
5198               bfd_put_64 (output_bfd, (bfd_vma) 0,
5199                           htab->elf.sgot->contents + htab->tlsdesc_got);
5200
5201               memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5202                       abed->plt0_entry, abed->plt_entry_size);
5203
5204               /* Add offset for pushq GOT+8(%rip), since the
5205                  instruction uses 6 bytes subtract this value.  */
5206               bfd_put_32 (output_bfd,
5207                           (htab->elf.sgotplt->output_section->vma
5208                            + htab->elf.sgotplt->output_offset
5209                            + 8
5210                            - htab->elf.splt->output_section->vma
5211                            - htab->elf.splt->output_offset
5212                            - htab->tlsdesc_plt
5213                            - 6),
5214                           htab->elf.splt->contents
5215                           + htab->tlsdesc_plt + abed->plt0_got1_offset);
5216           /* Add offset for the PC-relative instruction accessing GOT+TDG,
5217              where TGD stands for htab->tlsdesc_got, subtracting the offset
5218              to the end of that instruction.  */
5219               bfd_put_32 (output_bfd,
5220                           (htab->elf.sgot->output_section->vma
5221                            + htab->elf.sgot->output_offset
5222                            + htab->tlsdesc_got
5223                            - htab->elf.splt->output_section->vma
5224                            - htab->elf.splt->output_offset
5225                            - htab->tlsdesc_plt
5226                            - abed->plt0_got2_insn_end),
5227                           htab->elf.splt->contents
5228                           + htab->tlsdesc_plt + abed->plt0_got2_offset);
5229             }
5230         }
5231     }
5232
5233   if (htab->plt_bnd != NULL)
5234     elf_section_data (htab->plt_bnd->output_section)
5235       ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
5236
5237   if (htab->elf.sgotplt)
5238     {
5239       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5240         {
5241           (*_bfd_error_handler)
5242             (_("discarded output section: `%A'"), htab->elf.sgotplt);
5243           return FALSE;
5244         }
5245
5246       /* Fill in the first three entries in the global offset table.  */
5247       if (htab->elf.sgotplt->size > 0)
5248         {
5249           /* Set the first entry in the global offset table to the address of
5250              the dynamic section.  */
5251           if (sdyn == NULL)
5252             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
5253           else
5254             bfd_put_64 (output_bfd,
5255                         sdyn->output_section->vma + sdyn->output_offset,
5256                         htab->elf.sgotplt->contents);
5257           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
5258           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
5259           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
5260         }
5261
5262       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
5263         GOT_ENTRY_SIZE;
5264     }
5265
5266   /* Adjust .eh_frame for .plt section.  */
5267   if (htab->plt_eh_frame != NULL
5268       && htab->plt_eh_frame->contents != NULL)
5269     {
5270       if (htab->elf.splt != NULL
5271           && htab->elf.splt->size != 0
5272           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5273           && htab->elf.splt->output_section != NULL
5274           && htab->plt_eh_frame->output_section != NULL)
5275         {
5276           bfd_vma plt_start = htab->elf.splt->output_section->vma;
5277           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5278                                    + htab->plt_eh_frame->output_offset
5279                                    + PLT_FDE_START_OFFSET;
5280           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5281                              htab->plt_eh_frame->contents
5282                              + PLT_FDE_START_OFFSET);
5283         }
5284       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5285         {
5286           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5287                                                  htab->plt_eh_frame,
5288                                                  htab->plt_eh_frame->contents))
5289             return FALSE;
5290         }
5291     }
5292
5293   if (htab->elf.sgot && htab->elf.sgot->size > 0)
5294     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
5295       = GOT_ENTRY_SIZE;
5296
5297   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
5298   htab_traverse (htab->loc_hash_table,
5299                  elf_x86_64_finish_local_dynamic_symbol,
5300                  info);
5301
5302   return TRUE;
5303 }
5304
5305 /* Return address in section PLT for the Ith GOTPLT relocation, for
5306    relocation REL or (bfd_vma) -1 if it should not be included.  */
5307
5308 static bfd_vma
5309 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
5310                         const arelent *rel)
5311 {
5312   bfd *abfd;
5313   const struct elf_x86_64_backend_data *bed;
5314   bfd_vma plt_offset;
5315
5316   /* Only match R_X86_64_JUMP_SLOT and R_X86_64_IRELATIVE.  */
5317   if (rel->howto->type != R_X86_64_JUMP_SLOT
5318       && rel->howto->type != R_X86_64_IRELATIVE)
5319     return (bfd_vma) -1;
5320
5321   abfd = plt->owner;
5322   bed = get_elf_x86_64_backend_data (abfd);
5323   plt_offset = bed->plt_entry_size;
5324
5325   if (elf_elfheader (abfd)->e_ident[EI_OSABI] != ELFOSABI_GNU)
5326     return plt->vma + (i + 1) * plt_offset;
5327
5328   while (plt_offset < plt->size)
5329     {
5330       bfd_vma reloc_index;
5331       bfd_byte reloc_index_raw[4];
5332
5333       if (!bfd_get_section_contents (abfd, (asection *) plt,
5334                                      reloc_index_raw,
5335                                      plt_offset + bed->plt_reloc_offset,
5336                                      sizeof (reloc_index_raw)))
5337         return (bfd_vma) -1;
5338
5339       reloc_index = H_GET_32 (abfd, reloc_index_raw);
5340       if (reloc_index == i)
5341         return plt->vma + plt_offset;
5342       plt_offset += bed->plt_entry_size;
5343     }
5344
5345   abort ();
5346 }
5347
5348 /* Return offset in .plt.bnd section for the Ith GOTPLT relocation with
5349    PLT section, or (bfd_vma) -1 if it should not be included.  */
5350
5351 static bfd_vma
5352 elf_x86_64_plt_sym_val_offset_plt_bnd (bfd_vma i, const asection *plt)
5353 {
5354   const struct elf_x86_64_backend_data *bed = &elf_x86_64_bnd_arch_bed;
5355   bfd *abfd = plt->owner;
5356   bfd_vma plt_offset = bed->plt_entry_size;
5357
5358   if (elf_elfheader (abfd)->e_ident[EI_OSABI] != ELFOSABI_GNU)
5359     return i * sizeof (elf_x86_64_legacy_plt2_entry);
5360
5361   while (plt_offset < plt->size)
5362     {
5363       bfd_vma reloc_index;
5364       bfd_byte reloc_index_raw[4];
5365
5366       if (!bfd_get_section_contents (abfd, (asection *) plt,
5367                                      reloc_index_raw,
5368                                      plt_offset + bed->plt_reloc_offset,
5369                                      sizeof (reloc_index_raw)))
5370         return (bfd_vma) -1;
5371
5372       reloc_index = H_GET_32 (abfd, reloc_index_raw);
5373       if (reloc_index == i)
5374         {
5375           /* This is the index in .plt section.  */
5376           long plt_index = plt_offset / bed->plt_entry_size;
5377           /* Return the offset in .plt.bnd section.  */
5378           return (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry);
5379         }
5380       plt_offset += bed->plt_entry_size;
5381     }
5382
5383   abort ();
5384 }
5385
5386 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5387    support.  */
5388
5389 static long
5390 elf_x86_64_get_synthetic_symtab (bfd *abfd,
5391                                  long symcount,
5392                                  asymbol **syms,
5393                                  long dynsymcount,
5394                                  asymbol **dynsyms,
5395                                  asymbol **ret)
5396 {
5397   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5398   asection *relplt;
5399   asymbol *s;
5400   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5401   arelent *p;
5402   long count, i, n;
5403   size_t size;
5404   Elf_Internal_Shdr *hdr;
5405   char *names;
5406   asection *plt, *plt_push;
5407
5408   plt_push = bfd_get_section_by_name (abfd, ".plt");
5409   if (plt_push == NULL)
5410     return 0;
5411
5412   plt = bfd_get_section_by_name (abfd, ".plt.bnd");
5413   /* Use the generic ELF version if there is no .plt.bnd section.  */
5414   if (plt == NULL)
5415     return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
5416                                           dynsymcount, dynsyms, ret);
5417
5418   *ret = NULL;
5419
5420   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
5421     return 0;
5422
5423   if (dynsymcount <= 0)
5424     return 0;
5425
5426   relplt = bfd_get_section_by_name (abfd, ".rela.plt");
5427   if (relplt == NULL)
5428     return 0;
5429
5430   hdr = &elf_section_data (relplt)->this_hdr;
5431   if (hdr->sh_link != elf_dynsymtab (abfd)
5432       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
5433     return 0;
5434
5435   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5436   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5437     return -1;
5438
5439   count = relplt->size / hdr->sh_entsize;
5440   size = count * sizeof (asymbol);
5441   p = relplt->relocation;
5442   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
5443     {
5444       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
5445       if (p->addend != 0)
5446         size += sizeof ("+0x") - 1 + 8 + 8;
5447     }
5448
5449   s = *ret = (asymbol *) bfd_malloc (size);
5450   if (s == NULL)
5451     return -1;
5452
5453   names = (char *) (s + count);
5454   p = relplt->relocation;
5455   n = 0;
5456   for (i = 0; i < count; i++, p++)
5457     {
5458       bfd_vma offset;
5459       size_t len;
5460
5461       if (p->howto->type != R_X86_64_JUMP_SLOT
5462           && p->howto->type != R_X86_64_IRELATIVE)
5463         continue;
5464
5465       offset = elf_x86_64_plt_sym_val_offset_plt_bnd (i, plt_push);
5466
5467       *s = **p->sym_ptr_ptr;
5468       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
5469          we are defining a symbol, ensure one of them is set.  */
5470       if ((s->flags & BSF_LOCAL) == 0)
5471         s->flags |= BSF_GLOBAL;
5472       s->flags |= BSF_SYNTHETIC;
5473       s->section = plt;
5474       s->value = offset;
5475       s->name = names;
5476       s->udata.p = NULL;
5477       len = strlen ((*p->sym_ptr_ptr)->name);
5478       memcpy (names, (*p->sym_ptr_ptr)->name, len);
5479       names += len;
5480       if (p->addend != 0)
5481         {
5482           char buf[30], *a;
5483
5484           memcpy (names, "+0x", sizeof ("+0x") - 1);
5485           names += sizeof ("+0x") - 1;
5486           bfd_sprintf_vma (abfd, buf, p->addend);
5487           for (a = buf; *a == '0'; ++a)
5488             ;
5489           len = strlen (a);
5490           memcpy (names, a, len);
5491           names += len;
5492         }
5493       memcpy (names, "@plt", sizeof ("@plt"));
5494       names += sizeof ("@plt");
5495       ++s, ++n;
5496     }
5497
5498   return n;
5499 }
5500
5501 /* Handle an x86-64 specific section when reading an object file.  This
5502    is called when elfcode.h finds a section with an unknown type.  */
5503
5504 static bfd_boolean
5505 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
5506                               const char *name, int shindex)
5507 {
5508   if (hdr->sh_type != SHT_X86_64_UNWIND)
5509     return FALSE;
5510
5511   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5512     return FALSE;
5513
5514   return TRUE;
5515 }
5516
5517 /* Hook called by the linker routine which adds symbols from an object
5518    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5519    of .bss.  */
5520
5521 static bfd_boolean
5522 elf_x86_64_add_symbol_hook (bfd *abfd,
5523                             struct bfd_link_info *info,
5524                             Elf_Internal_Sym *sym,
5525                             const char **namep ATTRIBUTE_UNUSED,
5526                             flagword *flagsp ATTRIBUTE_UNUSED,
5527                             asection **secp,
5528                             bfd_vma *valp)
5529 {
5530   asection *lcomm;
5531
5532   switch (sym->st_shndx)
5533     {
5534     case SHN_X86_64_LCOMMON:
5535       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
5536       if (lcomm == NULL)
5537         {
5538           lcomm = bfd_make_section_with_flags (abfd,
5539                                                "LARGE_COMMON",
5540                                                (SEC_ALLOC
5541                                                 | SEC_IS_COMMON
5542                                                 | SEC_LINKER_CREATED));
5543           if (lcomm == NULL)
5544             return FALSE;
5545           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
5546         }
5547       *secp = lcomm;
5548       *valp = sym->st_size;
5549       return TRUE;
5550     }
5551
5552   if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5553        || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
5554       && (abfd->flags & DYNAMIC) == 0
5555       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5556     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5557
5558   return TRUE;
5559 }
5560
5561
5562 /* Given a BFD section, try to locate the corresponding ELF section
5563    index.  */
5564
5565 static bfd_boolean
5566 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5567                                          asection *sec, int *index_return)
5568 {
5569   if (sec == &_bfd_elf_large_com_section)
5570     {
5571       *index_return = SHN_X86_64_LCOMMON;
5572       return TRUE;
5573     }
5574   return FALSE;
5575 }
5576
5577 /* Process a symbol.  */
5578
5579 static void
5580 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5581                               asymbol *asym)
5582 {
5583   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5584
5585   switch (elfsym->internal_elf_sym.st_shndx)
5586     {
5587     case SHN_X86_64_LCOMMON:
5588       asym->section = &_bfd_elf_large_com_section;
5589       asym->value = elfsym->internal_elf_sym.st_size;
5590       /* Common symbol doesn't set BSF_GLOBAL.  */
5591       asym->flags &= ~BSF_GLOBAL;
5592       break;
5593     }
5594 }
5595
5596 static bfd_boolean
5597 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5598 {
5599   return (sym->st_shndx == SHN_COMMON
5600           || sym->st_shndx == SHN_X86_64_LCOMMON);
5601 }
5602
5603 static unsigned int
5604 elf_x86_64_common_section_index (asection *sec)
5605 {
5606   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5607     return SHN_COMMON;
5608   else
5609     return SHN_X86_64_LCOMMON;
5610 }
5611
5612 static asection *
5613 elf_x86_64_common_section (asection *sec)
5614 {
5615   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5616     return bfd_com_section_ptr;
5617   else
5618     return &_bfd_elf_large_com_section;
5619 }
5620
5621 static bfd_boolean
5622 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
5623                          const Elf_Internal_Sym *sym,
5624                          asection **psec,
5625                          bfd_boolean newdef,
5626                          bfd_boolean olddef,
5627                          bfd *oldbfd,
5628                          const asection *oldsec)
5629 {
5630   /* A normal common symbol and a large common symbol result in a
5631      normal common symbol.  We turn the large common symbol into a
5632      normal one.  */
5633   if (!olddef
5634       && h->root.type == bfd_link_hash_common
5635       && !newdef
5636       && bfd_is_com_section (*psec)
5637       && oldsec != *psec)
5638     {
5639       if (sym->st_shndx == SHN_COMMON
5640           && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
5641         {
5642           h->root.u.c.p->section
5643             = bfd_make_section_old_way (oldbfd, "COMMON");
5644           h->root.u.c.p->section->flags = SEC_ALLOC;
5645         }
5646       else if (sym->st_shndx == SHN_X86_64_LCOMMON
5647                && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
5648         *psec = bfd_com_section_ptr;
5649     }
5650
5651   return TRUE;
5652 }
5653
5654 static int
5655 elf_x86_64_additional_program_headers (bfd *abfd,
5656                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
5657 {
5658   asection *s;
5659   int count = 0;
5660
5661   /* Check to see if we need a large readonly segment.  */
5662   s = bfd_get_section_by_name (abfd, ".lrodata");
5663   if (s && (s->flags & SEC_LOAD))
5664     count++;
5665
5666   /* Check to see if we need a large data segment.  Since .lbss sections
5667      is placed right after the .bss section, there should be no need for
5668      a large data segment just because of .lbss.  */
5669   s = bfd_get_section_by_name (abfd, ".ldata");
5670   if (s && (s->flags & SEC_LOAD))
5671     count++;
5672
5673   return count;
5674 }
5675
5676 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5677
5678 static bfd_boolean
5679 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5680 {
5681   if (h->plt.offset != (bfd_vma) -1
5682       && !h->def_regular
5683       && !h->pointer_equality_needed)
5684     return FALSE;
5685
5686   return _bfd_elf_hash_symbol (h);
5687 }
5688
5689 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5690
5691 static bfd_boolean
5692 elf_x86_64_relocs_compatible (const bfd_target *input,
5693                               const bfd_target *output)
5694 {
5695   return ((xvec_get_elf_backend_data (input)->s->elfclass
5696            == xvec_get_elf_backend_data (output)->s->elfclass)
5697           && _bfd_elf_relocs_compatible (input, output));
5698 }
5699
5700 static const struct bfd_elf_special_section
5701   elf_x86_64_special_sections[]=
5702 {
5703   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5704   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5705   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5706   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5707   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5708   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5709   { NULL,                       0,          0, 0,            0 }
5710 };
5711
5712 #define TARGET_LITTLE_SYM                   x86_64_elf64_vec
5713 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
5714 #define ELF_ARCH                            bfd_arch_i386
5715 #define ELF_TARGET_ID                       X86_64_ELF_DATA
5716 #define ELF_MACHINE_CODE                    EM_X86_64
5717 #define ELF_MAXPAGESIZE                     0x200000
5718 #define ELF_MINPAGESIZE                     0x1000
5719 #define ELF_COMMONPAGESIZE                  0x1000
5720
5721 #define elf_backend_can_gc_sections         1
5722 #define elf_backend_can_refcount            1
5723 #define elf_backend_want_got_plt            1
5724 #define elf_backend_plt_readonly            1
5725 #define elf_backend_want_plt_sym            0
5726 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
5727 #define elf_backend_rela_normal             1
5728 #define elf_backend_plt_alignment           4
5729
5730 #define elf_info_to_howto                   elf_x86_64_info_to_howto
5731
5732 #define bfd_elf64_bfd_link_hash_table_create \
5733   elf_x86_64_link_hash_table_create
5734 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
5735 #define bfd_elf64_bfd_reloc_name_lookup \
5736   elf_x86_64_reloc_name_lookup
5737
5738 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
5739 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
5740 #define elf_backend_check_relocs            elf_x86_64_check_relocs
5741 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
5742 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5743 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5744 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
5745 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
5746 #define elf_backend_gc_sweep_hook           elf_x86_64_gc_sweep_hook
5747 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
5748 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
5749 #ifdef CORE_HEADER
5750 #define elf_backend_write_core_note         elf_x86_64_write_core_note
5751 #endif
5752 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
5753 #define elf_backend_relocate_section        elf_x86_64_relocate_section
5754 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
5755 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
5756 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
5757 #define elf_backend_plt_sym_val             elf_x86_64_plt_sym_val
5758 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5759 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
5760 #define bfd_elf64_get_synthetic_symtab      elf_x86_64_get_synthetic_symtab
5761
5762 #define elf_backend_section_from_shdr \
5763         elf_x86_64_section_from_shdr
5764
5765 #define elf_backend_section_from_bfd_section \
5766   elf_x86_64_elf_section_from_bfd_section
5767 #define elf_backend_add_symbol_hook \
5768   elf_x86_64_add_symbol_hook
5769 #define elf_backend_symbol_processing \
5770   elf_x86_64_symbol_processing
5771 #define elf_backend_common_section_index \
5772   elf_x86_64_common_section_index
5773 #define elf_backend_common_section \
5774   elf_x86_64_common_section
5775 #define elf_backend_common_definition \
5776   elf_x86_64_common_definition
5777 #define elf_backend_merge_symbol \
5778   elf_x86_64_merge_symbol
5779 #define elf_backend_special_sections \
5780   elf_x86_64_special_sections
5781 #define elf_backend_additional_program_headers \
5782   elf_x86_64_additional_program_headers
5783 #define elf_backend_hash_symbol \
5784   elf_x86_64_hash_symbol
5785
5786 #include "elf64-target.h"
5787
5788 /* FreeBSD support.  */
5789
5790 #undef  TARGET_LITTLE_SYM
5791 #define TARGET_LITTLE_SYM                   x86_64_elf64_fbsd_vec
5792 #undef  TARGET_LITTLE_NAME
5793 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
5794
5795 #undef  ELF_OSABI
5796 #define ELF_OSABI                           ELFOSABI_FREEBSD
5797
5798 #undef  elf64_bed
5799 #define elf64_bed elf64_x86_64_fbsd_bed
5800
5801 #include "elf64-target.h"
5802
5803 /* Solaris 2 support.  */
5804
5805 #undef  TARGET_LITTLE_SYM
5806 #define TARGET_LITTLE_SYM                   x86_64_elf64_sol2_vec
5807 #undef  TARGET_LITTLE_NAME
5808 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
5809
5810 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5811    objects won't be recognized.  */
5812 #undef ELF_OSABI
5813
5814 #undef  elf64_bed
5815 #define elf64_bed                           elf64_x86_64_sol2_bed
5816
5817 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5818    boundary.  */
5819 #undef elf_backend_static_tls_alignment
5820 #define elf_backend_static_tls_alignment    16
5821
5822 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5823
5824    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5825    File, p.63.  */
5826 #undef elf_backend_want_plt_sym
5827 #define elf_backend_want_plt_sym            1
5828
5829 #include "elf64-target.h"
5830
5831 #undef bfd_elf64_get_synthetic_symtab
5832
5833 /* Native Client support.  */
5834
5835 static bfd_boolean
5836 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5837 {
5838   /* Set the right machine number for a NaCl x86-64 ELF64 file.  */
5839   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5840   return TRUE;
5841 }
5842
5843 #undef  TARGET_LITTLE_SYM
5844 #define TARGET_LITTLE_SYM               x86_64_elf64_nacl_vec
5845 #undef  TARGET_LITTLE_NAME
5846 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
5847 #undef  elf64_bed
5848 #define elf64_bed                       elf64_x86_64_nacl_bed
5849
5850 #undef  ELF_MAXPAGESIZE
5851 #undef  ELF_MINPAGESIZE
5852 #undef  ELF_COMMONPAGESIZE
5853 #define ELF_MAXPAGESIZE                 0x10000
5854 #define ELF_MINPAGESIZE                 0x10000
5855 #define ELF_COMMONPAGESIZE              0x10000
5856
5857 /* Restore defaults.  */
5858 #undef  ELF_OSABI
5859 #undef  elf_backend_static_tls_alignment
5860 #undef  elf_backend_want_plt_sym
5861 #define elf_backend_want_plt_sym        0
5862
5863 /* NaCl uses substantially different PLT entries for the same effects.  */
5864
5865 #undef  elf_backend_plt_alignment
5866 #define elf_backend_plt_alignment       5
5867 #define NACL_PLT_ENTRY_SIZE             64
5868 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5869
5870 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5871   {
5872     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
5873     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
5874     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5875     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5876     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5877
5878     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
5879     0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1)     */
5880
5881     /* 32 bytes of nop to pad out to the standard size.  */
5882     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5883     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5884     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5885     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5886     0x66,                                  /* excess data32 prefix      */
5887     0x90                                   /* nop */
5888   };
5889
5890 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5891   {
5892     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
5893     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5894     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5895     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5896
5897     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
5898     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5899     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5900
5901     /* Lazy GOT entries point here (32-byte aligned).  */
5902     0x68,                 /* pushq immediate */
5903     0, 0, 0, 0,           /* replaced with index into relocation table.  */
5904     0xe9,                 /* jmp relative */
5905     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
5906
5907     /* 22 bytes of nop to pad out to the standard size.  */
5908     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5909     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5910     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
5911   };
5912
5913 /* .eh_frame covering the .plt section.  */
5914
5915 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5916   {
5917 #if (PLT_CIE_LENGTH != 20                               \
5918      || PLT_FDE_LENGTH != 36                            \
5919      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5920      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5921 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5922 #endif
5923     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
5924     0, 0, 0, 0,                 /* CIE ID */
5925     1,                          /* CIE version */
5926     'z', 'R', 0,                /* Augmentation string */
5927     1,                          /* Code alignment factor */
5928     0x78,                       /* Data alignment factor */
5929     16,                         /* Return address column */
5930     1,                          /* Augmentation size */
5931     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5932     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5933     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
5934     DW_CFA_nop, DW_CFA_nop,
5935
5936     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
5937     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5938     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
5939     0, 0, 0, 0,                 /* .plt size goes here */
5940     0,                          /* Augmentation size */
5941     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
5942     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5943     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
5944     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5945     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
5946     13,                         /* Block length */
5947     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
5948     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
5949     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5950     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5951     DW_CFA_nop, DW_CFA_nop
5952   };
5953
5954 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5955   {
5956     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
5957     elf_x86_64_nacl_plt_entry,               /* plt_entry */
5958     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
5959     2,                                       /* plt0_got1_offset */
5960     9,                                       /* plt0_got2_offset */
5961     13,                                      /* plt0_got2_insn_end */
5962     3,                                       /* plt_got_offset */
5963     33,                                      /* plt_reloc_offset */
5964     38,                                      /* plt_plt_offset */
5965     7,                                       /* plt_got_insn_size */
5966     42,                                      /* plt_plt_insn_end */
5967     32,                                      /* plt_lazy_offset */
5968     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
5969     sizeof (elf_x86_64_nacl_eh_frame_plt),   /* eh_frame_plt_size */
5970   };
5971
5972 #undef  elf_backend_arch_data
5973 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
5974
5975 #undef  elf_backend_object_p
5976 #define elf_backend_object_p                    elf64_x86_64_nacl_elf_object_p
5977 #undef  elf_backend_modify_segment_map
5978 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5979 #undef  elf_backend_modify_program_headers
5980 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5981 #undef  elf_backend_final_write_processing
5982 #define elf_backend_final_write_processing      nacl_final_write_processing
5983
5984 #include "elf64-target.h"
5985
5986 /* Native Client x32 support.  */
5987
5988 static bfd_boolean
5989 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5990 {
5991   /* Set the right machine number for a NaCl x86-64 ELF32 file.  */
5992   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5993   return TRUE;
5994 }
5995
5996 #undef  TARGET_LITTLE_SYM
5997 #define TARGET_LITTLE_SYM               x86_64_elf32_nacl_vec
5998 #undef  TARGET_LITTLE_NAME
5999 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
6000 #undef  elf32_bed
6001 #define elf32_bed                       elf32_x86_64_nacl_bed
6002
6003 #define bfd_elf32_bfd_link_hash_table_create \
6004   elf_x86_64_link_hash_table_create
6005 #define bfd_elf32_bfd_reloc_type_lookup \
6006   elf_x86_64_reloc_type_lookup
6007 #define bfd_elf32_bfd_reloc_name_lookup \
6008   elf_x86_64_reloc_name_lookup
6009 #define bfd_elf32_mkobject \
6010   elf_x86_64_mkobject
6011
6012 #undef elf_backend_object_p
6013 #define elf_backend_object_p \
6014   elf32_x86_64_nacl_elf_object_p
6015
6016 #undef elf_backend_bfd_from_remote_memory
6017 #define elf_backend_bfd_from_remote_memory \
6018   _bfd_elf32_bfd_from_remote_memory
6019
6020 #undef elf_backend_size_info
6021 #define elf_backend_size_info \
6022   _bfd_elf32_size_info
6023
6024 #include "elf32-target.h"
6025
6026 /* Restore defaults.  */
6027 #undef  elf_backend_object_p
6028 #define elf_backend_object_p                elf64_x86_64_elf_object_p
6029 #undef  elf_backend_bfd_from_remote_memory
6030 #undef  elf_backend_size_info
6031 #undef  elf_backend_modify_segment_map
6032 #undef  elf_backend_modify_program_headers
6033 #undef  elf_backend_final_write_processing
6034
6035 /* Intel L1OM support.  */
6036
6037 static bfd_boolean
6038 elf64_l1om_elf_object_p (bfd *abfd)
6039 {
6040   /* Set the right machine number for an L1OM elf64 file.  */
6041   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6042   return TRUE;
6043 }
6044
6045 #undef  TARGET_LITTLE_SYM
6046 #define TARGET_LITTLE_SYM                   l1om_elf64_vec
6047 #undef  TARGET_LITTLE_NAME
6048 #define TARGET_LITTLE_NAME                  "elf64-l1om"
6049 #undef ELF_ARCH
6050 #define ELF_ARCH                            bfd_arch_l1om
6051
6052 #undef  ELF_MACHINE_CODE
6053 #define ELF_MACHINE_CODE                    EM_L1OM
6054
6055 #undef  ELF_OSABI
6056
6057 #undef  elf64_bed
6058 #define elf64_bed elf64_l1om_bed
6059
6060 #undef elf_backend_object_p
6061 #define elf_backend_object_p                elf64_l1om_elf_object_p
6062
6063 /* Restore defaults.  */
6064 #undef  ELF_MAXPAGESIZE
6065 #undef  ELF_MINPAGESIZE
6066 #undef  ELF_COMMONPAGESIZE
6067 #define ELF_MAXPAGESIZE                 0x200000
6068 #define ELF_MINPAGESIZE                 0x1000
6069 #define ELF_COMMONPAGESIZE              0x1000
6070 #undef  elf_backend_plt_alignment
6071 #define elf_backend_plt_alignment       4
6072 #undef  elf_backend_arch_data
6073 #define elf_backend_arch_data   &elf_x86_64_arch_bed
6074
6075 #include "elf64-target.h"
6076
6077 /* FreeBSD L1OM support.  */
6078
6079 #undef  TARGET_LITTLE_SYM
6080 #define TARGET_LITTLE_SYM                   l1om_elf64_fbsd_vec
6081 #undef  TARGET_LITTLE_NAME
6082 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
6083
6084 #undef  ELF_OSABI
6085 #define ELF_OSABI                           ELFOSABI_FREEBSD
6086
6087 #undef  elf64_bed
6088 #define elf64_bed elf64_l1om_fbsd_bed
6089
6090 #include "elf64-target.h"
6091
6092 /* Intel K1OM support.  */
6093
6094 static bfd_boolean
6095 elf64_k1om_elf_object_p (bfd *abfd)
6096 {
6097   /* Set the right machine number for an K1OM elf64 file.  */
6098   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6099   return TRUE;
6100 }
6101
6102 #undef  TARGET_LITTLE_SYM
6103 #define TARGET_LITTLE_SYM                   k1om_elf64_vec
6104 #undef  TARGET_LITTLE_NAME
6105 #define TARGET_LITTLE_NAME                  "elf64-k1om"
6106 #undef ELF_ARCH
6107 #define ELF_ARCH                            bfd_arch_k1om
6108
6109 #undef  ELF_MACHINE_CODE
6110 #define ELF_MACHINE_CODE                    EM_K1OM
6111
6112 #undef  ELF_OSABI
6113
6114 #undef  elf64_bed
6115 #define elf64_bed elf64_k1om_bed
6116
6117 #undef elf_backend_object_p
6118 #define elf_backend_object_p                elf64_k1om_elf_object_p
6119
6120 #undef  elf_backend_static_tls_alignment
6121
6122 #undef elf_backend_want_plt_sym
6123 #define elf_backend_want_plt_sym            0
6124
6125 #include "elf64-target.h"
6126
6127 /* FreeBSD K1OM support.  */
6128
6129 #undef  TARGET_LITTLE_SYM
6130 #define TARGET_LITTLE_SYM                   k1om_elf64_fbsd_vec
6131 #undef  TARGET_LITTLE_NAME
6132 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
6133
6134 #undef  ELF_OSABI
6135 #define ELF_OSABI                           ELFOSABI_FREEBSD
6136
6137 #undef  elf64_bed
6138 #define elf64_bed elf64_k1om_fbsd_bed
6139
6140 #include "elf64-target.h"
6141
6142 /* 32bit x86-64 support.  */
6143
6144 #undef  TARGET_LITTLE_SYM
6145 #define TARGET_LITTLE_SYM                   x86_64_elf32_vec
6146 #undef  TARGET_LITTLE_NAME
6147 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
6148 #undef  elf32_bed
6149
6150 #undef ELF_ARCH
6151 #define ELF_ARCH                            bfd_arch_i386
6152
6153 #undef  ELF_MACHINE_CODE
6154 #define ELF_MACHINE_CODE                    EM_X86_64
6155
6156 #undef  ELF_OSABI
6157
6158 #undef elf_backend_object_p
6159 #define elf_backend_object_p \
6160   elf32_x86_64_elf_object_p
6161
6162 #undef elf_backend_bfd_from_remote_memory
6163 #define elf_backend_bfd_from_remote_memory \
6164   _bfd_elf32_bfd_from_remote_memory
6165
6166 #undef elf_backend_size_info
6167 #define elf_backend_size_info \
6168   _bfd_elf32_size_info
6169
6170 #include "elf32-target.h"