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