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