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