bfd/elf64-x86-64.c

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