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