bfd/elf64-x86-64.c

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