bfd/elf64-x86-64.c

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