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